À propos de ce cours
Objectifs de la leçon
- Configurer HttpClient et l'adresse de l'API par environnement.
- Écrire un service Angular typé qui appelle l'API NestJS.
- Gérer chargement, données et erreurs dans un composant avec des signaux.
- Afficher les erreurs de validation renvoyées par l'API.
Le composant ne connaît pas les URL : il appelle un service, qui utilise HttpClient.
Configuration
📄 apps/web/src/environments/environment.development.ts
// Développement : Angular sur http://localhost:4200, NestJS sur http://localhost:3000
export const environment = {
production: false,
apiUrl: 'http://localhost:3000/api',
};
📄 apps/web/src/environments/environment.ts
// Production : l'application et l'API sont servies par le même domaine (nginx, chapitre 20)
export const environment = {
production: true,
apiUrl: '/api',
};
Dans angular.json, la configuration development remplace le premier fichier par le second (fileReplacements, ajouté par ng generate environments). ng serve utilise donc l'URL de développement, ng build celle de production.
📄 apps/web/src/app/app.config.ts
import { provideHttpClient, withFetch, withInterceptors } from '@angular/common/http';
import { ApplicationConfig, provideBrowserGlobalErrorListeners } from '@angular/core';
import { provideRouter, withComponentInputBinding } from '@angular/router';
import { routes } from './app.routes';
import { authInterceptor } from './core/auth.interceptor';
export const appConfig: ApplicationConfig = {
providers: [
provideBrowserGlobalErrorListeners(),
provideRouter(routes, withComponentInputBinding()),
provideHttpClient(withFetch(), withInterceptors([authInterceptor])),
],
};
provideHttpClient()rendHttpClientinjectable ;withFetch()utilise l'APIfetchdu navigateur ;withInterceptorssera détaillé à la leçon 18.4.withComponentInputBinding()transmet les paramètres de route (:id) et de requête (?retour=) auxinput()des composants.
Un service par ressource
📄 apps/web/src/app/formations/formations.service.ts
import { HttpClient, HttpParams } from '@angular/common/http';
import { inject, Injectable } from '@angular/core';
import type { CreerFormation, Formation, ModifierFormation, Niveau, Page } from '@formation/partage';
import { environment } from '../../environments/environment';
@Injectable({ providedIn: 'root' })
export class FormationsService {
private readonly http = inject(HttpClient);
private readonly url = `${environment.apiUrl}/formations`;
lister(filtre: { q?: string; niveau?: Niveau | '' } = {}) {
let params = new HttpParams();
if (filtre.q) params = params.set('q', filtre.q);
if (filtre.niveau) params = params.set('niveau', filtre.niveau);
return this.http.get<Page<Formation>>(this.url, { params });
}
trouver(id: number) {
return this.http.get<Formation>(`${this.url}/${id}`);
}
creer(donnees: CreerFormation) {
return this.http.post<Formation>(this.url, donnees);
}
modifier(id: number, donnees: ModifierFormation) {
return this.http.patch<Formation>(`${this.url}/${id}`, donnees);
}
supprimer(id: number) {
return this.http.delete<void>(`${this.url}/${id}`);
}
}
- Une méthode par route de l'API ; le composant ne manipule jamais d'URL.
get<Page<Formation>>type la réponse avec les interfaces du paquet partagé. Attention : c'est une promesse de type, pas une vérification. Si l'API renvoie autre chose, TypeScript ne le saura pas ; d'où l'intérêt de partager les types avec l'API (leçon 18.5).HttpParamsconstruit?q=…&niveau=…en encodant correctement les valeurs ; on n'ajoute un paramètre que s'il a une valeur.- Les méthodes renvoient des
Observable: la requête ne part qu'ausubscribe().
Les composants
📄 apps/web/src/app/formations/liste.ts
import { Component, inject, OnInit, signal } from '@angular/core';
import { FormsModule } from '@angular/forms';
import { RouterLink } from '@angular/router';
import type { Formation, Niveau } from '@formation/partage';
import { AuthService } from '../core/auth.service';
import { messagesErreur } from '../core/erreurs';
import { FormationsService } from './formations.service';
@Component({
selector: 'app-liste-formations',
imports: [FormsModule, RouterLink],
template: `
<h1>Catalogue des formations</h1>
<form class="filtres" (ngSubmit)="charger()">
<input name="q" [(ngModel)]="q" placeholder="Rechercher un intitulé…" />
<select name="niveau" [(ngModel)]="niveau" (change)="charger()">
<option value="">Tous les niveaux</option>
<option value="debutant">Débutant</option>
<option value="intermediaire">Intermédiaire</option>
<option value="avance">Avancé</option>
</select>
<button>Rechercher</button>
@if (auth.estAdmin()) { <a class="bouton" routerLink="/admin/nouvelle">+ Nouvelle formation</a> }
</form>
@if (chargement()) {
<p class="info">Chargement…</p>
} @else if (erreurs().length) {
<p class="erreur">{{ erreurs().join(' ; ') }}</p>
} @else {
<p class="info">{{ formations().length }} formation(s)</p>
<div class="cartes">
@for (f of formations(); track f.id) {
<a class="carte" [routerLink]="['/formations', f.id]">
<span class="badge {{ f.niveau }}">{{ f.niveau }}</span>
<h2>{{ f.intitule }}</h2>
<p>{{ f.description }}</p>
<small>{{ f.dureeHeures }} h · {{ f.places }} places</small>
</a>
} @empty {
<p>Aucune formation ne correspond.</p>
}
</div>
}
`,
})
export class ListeFormations implements OnInit {
private readonly service = inject(FormationsService);
protected readonly auth = inject(AuthService);
protected q = '';
protected niveau: Niveau | '' = '';
protected readonly formations = signal<Formation[]>([]);
protected readonly chargement = signal(false);
protected readonly erreurs = signal<string[]>([]);
ngOnInit() {
this.charger();
}
charger() {
this.chargement.set(true);
this.erreurs.set([]);
this.service.lister({ q: this.q.trim(), niveau: this.niveau }).subscribe({
next: (page) => {
this.formations.set(page.donnees);
this.chargement.set(false);
},
error: (e) => {
this.erreurs.set(messagesErreur(e));
this.chargement.set(false);
},
});
}
}
📄 apps/web/src/app/core/erreurs.ts
import { HttpErrorResponse } from '@angular/common/http';
import type { ErreurApi } from '@formation/partage';
// Transforme une erreur HTTP en liste de messages lisibles
export function messagesErreur(err: unknown): string[] {
if (!(err instanceof HttpErrorResponse)) return ['Erreur inattendue'];
if (err.status === 0) return ['API injoignable : serveur arrêté, ou requête bloquée par CORS'];
const corps = err.error as ErreurApi | null;
const m = corps?.message ?? err.message;
return Array.isArray(m) ? m : [m];
}
Trois signaux décrivent l'état de l'écran : chargement, formations, erreurs. Le template affiche l'un des trois cas avec @if / @else if. messagesErreur traduit toute erreur HTTP en messages : statut 0 (API arrêtée ou CORS), message simple (404, 409) ou tableau de messages (400 du ValidationPipe).
📄 apps/web/src/app/formations/detail.ts
import { Component, inject, input, OnInit, signal } from '@angular/core';
import { Router, RouterLink } from '@angular/router';
import type { Formation } from '@formation/partage';
import { AuthService } from '../core/auth.service';
import { messagesErreur } from '../core/erreurs';
import { FormationsService } from './formations.service';
@Component({
selector: 'app-detail-formation',
imports: [RouterLink],
template: `
<a routerLink="/">← Retour au catalogue</a>
@if (formation(); as f) {
<h1>{{ f.intitule }}</h1>
<p><span class="badge {{ f.niveau }}">{{ f.niveau }}</span> {{ f.dureeHeures }} heures · {{ f.places }} places</p>
<p>{{ f.description }}</p>
@if (auth.estAdmin()) {
<button class="danger" (click)="supprimer(f)">Supprimer</button>
}
}
@if (erreurs().length) { <p class="erreur">{{ erreurs().join(' ; ') }}</p> }
`,
})
export class DetailFormation implements OnInit {
// Le paramètre de route :id arrive directement dans un input (withComponentInputBinding)
readonly id = input.required<string>();
private readonly service = inject(FormationsService);
private readonly router = inject(Router);
protected readonly auth = inject(AuthService);
protected readonly formation = signal<Formation | null>(null);
protected readonly erreurs = signal<string[]>([]);
ngOnInit() {
this.service.trouver(Number(this.id())).subscribe({
next: (f) => this.formation.set(f),
error: (e) => this.erreurs.set(messagesErreur(e)),
});
}
supprimer(f: Formation) {
if (!confirm(`Supprimer « ${f.intitule} » ?`)) return;
this.service.supprimer(f.id).subscribe({
next: () => this.router.navigate(['/']),
error: (e) => this.erreurs.set(messagesErreur(e)),
});
}
}
📄 apps/web/src/app/formations/formulaire.ts
import { Component, inject, signal } from '@angular/core';
import { NonNullableFormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
import { Router } from '@angular/router';
import type { CreerFormation } from '@formation/partage';
import { messagesErreur } from '../core/erreurs';
import { FormationsService } from './formations.service';
@Component({
selector: 'app-formulaire-formation',
imports: [ReactiveFormsModule],
template: `
<h1>Nouvelle formation</h1>
<form class="formulaire" [formGroup]="form" (ngSubmit)="enregistrer()">
<label>Intitulé <input formControlName="intitule" /></label>
<label>Description <textarea formControlName="description" rows="3"></textarea></label>
<label>Niveau
<select formControlName="niveau">
<option value="debutant">Débutant</option>
<option value="intermediaire">Intermédiaire</option>
<option value="avance">Avancé</option>
</select>
</label>
<label>Durée (heures) <input type="number" formControlName="dureeHeures" /></label>
<label>Places <input type="number" formControlName="places" /></label>
@if (erreurs().length) {
<ul class="erreur">@for (m of erreurs(); track m) { <li>{{ m }}</li> }</ul>
}
<button [disabled]="envoi()">Enregistrer</button>
</form>
`,
})
export class FormulaireFormation {
private readonly service = inject(FormationsService);
private readonly router = inject(Router);
protected readonly erreurs = signal<string[]>([]);
protected readonly envoi = signal(false);
// Validation côté client pour le confort ; l'API valide de toute façon (la seule qui compte)
protected readonly form = inject(NonNullableFormBuilder).group({
intitule: ['', [Validators.required, Validators.minLength(3)]],
description: [''],
niveau: ['debutant' as CreerFormation['niveau']],
dureeHeures: [20],
places: [15],
});
enregistrer() {
this.envoi.set(true);
this.erreurs.set([]);
this.service.creer(this.form.getRawValue()).subscribe({
next: (f) => this.router.navigate(['/formations', f.id]),
error: (e) => {
this.erreurs.set(messagesErreur(e)); // les messages du ValidationPipe de NestJS
this.envoi.set(false);
},
});
}
}
Le résultat dans Chrome

La liste, chargée depuis GET /api/formations.
Résultat réellement obtenu (extrait du parcours dans Chrome) :
1. Catalogue (visiteur)
→ GET /api/formations [sans jeton]
← 200 /api/formations
2. Filtre « Intermédiaire »
→ GET /api/formations?niveau=intermediaire [sans jeton]
← 200 /api/formations?niveau=intermediaire
cartes affichées : 2
Changer de niveau envoie une nouvelle requête avec le paramètre niveau: le filtrage est fait par l'API, pas par Angular.

Le formulaire après un refus de l'API : les messages du ValidationPipe de NestJS, affichés tels quels.
Résultat réellement obtenu (extrait du parcours dans Chrome) :
6. Formulaire refusé par la validation de NestJS (description trop courte, 0 place)
→ POST /api/formations [Authorization: Bearer eyJhbGciOiJIU…]
← 400 /api/formations
[console] Failed to load resource: the server responded with a status of 400 (Bad Request)
messages : description must be longer than or equal to 10 characters | places must not be less than 1
7. Formulaire corrigé
→ POST /api/formations [Authorization: Bearer eyJhbGciOiJIU…]
← 201 /api/formations
→ GET /api/formations/5 [Authorization: Bearer eyJhbGciOiJIU…]
← 200 /api/formations/5
URL obtenue : /formations/5 — titre : Docker pour les développeurs
La validation côté client (intitulé obligatoire) évite des allers-retours inutiles, mais ne connaît pas toutes les règles : c'est NestJS qui a refusé la description trop courte et le nombre de places. Après correction, l'API répond 201 et Angular navigue vers la page de la nouvelle formation.

La page de détail, chargée avec l'identifiant de l'URL (input id).
Et httpResource? Les versions récentes d'Angular proposent aussi httpResource(), qui expose directement la réponse d'une requête GET sous forme de signaux (value(), isLoading(), error()) et la relance quand ses paramètres changent. Le modèle de cette leçon (service + subscribe + signaux) reste le plus répandu et convient à toutes les requêtes, y compris POST, PATCH et DELETE.
Activités
Activité 1 Modifier une formation
Ajoutez la route admin/formations/:id/modifier qui réutilise FormulaireFormation: si l'input id est présent, chargez la formation, remplissez le formulaire avec setValue, puis appelez modifier() au lieu de creer().
Voir le corrigé
readonly id = input<string>();
ngOnInit() {
const id = this.id();
if (id) this.service.trouver(Number(id)).subscribe((f) => {
const { id: _, ...donnees } = f;
this.form.setValue(donnees);
});
}
enregistrer() {
const id = this.id();
const requete = id ? this.service.modifier(Number(id), this.form.getRawValue()) : this.service.creer(this.form.getRawValue());
requete.subscribe({ next: (f) => this.router.navigate(['/formations', f.id]), error: (e) => this.erreurs.set(messagesErreur(e)) });
}
C'est la démarche du TP 12 pour les stagiaires.
Activité 2 Recherche au fil de la saisie
Lancez la recherche pendant la frappe, mais au plus une requête toutes les 300 ms et seulement si le texte a changé. Utilisez un Subject et les opérateurs debounceTime, distinctUntilChanged et switchMap. Pourquoi switchMap?
Voir le corrigé
private readonly saisie = new Subject<string>();
constructor() {
this.saisie.pipe(
debounceTime(300),
distinctUntilChanged(),
switchMap((q) => this.service.lister({ q, niveau: this.niveau })),
takeUntilDestroyed(),
).subscribe((page) => this.formations.set(page.donnees));
}
// template : <input (input)="saisie.next($any($event.target).value)" />
switchMap annule la requête précédente quand une nouvelle arrive : une réponse lente pour « ang » ne peut pas écraser celle de « angular » arrivée avant elle.
Activité 3 Un état de chargement fiable
Arrêtez l'API (Ctrl+C dans son terminal) et rechargez le catalogue. Qu'affiche l'application ? Ajoutez un bouton « Réessayer » qui rappelle charger().
Voir le corrigé
Le message « API injoignable : serveur arrêté, ou requête bloquée par CORS » (statut 0), et non un écran blanc ou un chargement infini : c'est le rôle du signal erreurs et de messagesErreur. Le bouton : <button (click)="charger()">Réessayer</button> dans le bloc @else if (erreurs().length).
Activité 4 Le type n'est pas une vérification
Dans l'API, renommez temporairement la propriété places en nbPlaces dans la réponse, sans toucher à Angular. L'application compile-t-elle ? Qu'affiche-t-elle ? Quelle leçon du chapitre évite ce problème ?
Voir le corrigé
Angular compile (son type Formation n'a pas changé) mais affiche « undefined places » : le type générique de get<Formation> n'a rien vérifié à l'exécution. Avec les interfaces partagées de la leçon 18.5, renommer la propriété dans le type commun fait échouer la compilation de l'API et d'Angular tant que les deux ne sont pas corrigés.
À retenir
- provideHttpClient(withFetch(), withInterceptors([…])) ; environment.apiUrl différent en développement et en production.
- Un service par ressource, une méthode par route, des Observable typés ; HttpParams pour les filtres.
- Signaux chargement / données / erreurs, et @if pour afficher le bon état.
- Statut 0 = API injoignable ou CORS ; 400 = tableau de messages du ValidationPipe à afficher.
- withComponentInputBinding : :id et ?retour= arrivent dans des input().
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !