Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
NestJS

Consommer une API NestJS depuis Angular (HttpClient, services)

Cette leçon connecte réellement l'application Angular à l'API NestJS. Elle configure provideHttpClient et les fichiers d'environnement avec l'adresse de l'API, puis écrit un service typé par ressource...

0 chapitres 0 QCM Accès gratuit
Consommer une API NestJS depuis Angular (HttpClient, services)

À propos de ce cours

Cette leçon connecte réellement l'application Angular à l'API NestJS. Elle configure provideHttpClient et les fichiers d'environnement avec l'adresse de l'API, puis écrit un service typé par ressource, avec une méthode par route et des HttpParams pour les filtres. Les composants gèrent chargement, données et erreurs avec des signaux. Ils lisent le paramètre de route grâce à withComponentInputBinding et affichent sous le formulaire les messages de validation renvoyés par NestJS. Les captures et le journal des requêtes proviennent d'un vrai parcours dans Chrome. Activités corrigées.

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.

Couches côté Angular

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() rend HttpClient injectable ; withFetch() utilise l'API fetch du navigateur ; withInterceptors sera détaillé à la leçon 18.4.
  • withComponentInputBinding() transmet les paramètres de route (:id) et de requête (?retour=) aux input() 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).
  • HttpParams construit ?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'au subscribe().
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

Catalogue des formations

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.

Erreurs de validation renvoyées par NestJS

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.

Page de détail

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é ?