~10 min de lecture

Deux commandes pour un seul clic : les 4 trous de ta protection anti-double-soumission

TL;DR

  • Le ticket type : deux commandes identiques créées à 380 ms d'écart, et un dev qui jure que "le bouton est disabled". Le [disabled] est de l'UX, pas une protection.
  • Trou 1 : (ngSubmit) sur le form et (click) sur le bouton submit. Un seul clic, deux appels, et le disabled n'y peut rien.
  • Trou 2 : le flag submitting posé après un await. Pendant la fenêtre asynchrone, tous les clics passent.
  • Trou 3 : le flag redescendu uniquement dans le next. Première erreur HTTP, bouton mort, et quelqu'un "corrige" en retirant le disabled.
  • Trou 4 : tout ce que ton composant ne voit pas (deuxième onglet, timeout, retry() d'interceptor). La réponse est côté API : une clé d'idempotence (un identifiant joint à la requête pour que le serveur reconnaisse un doublon), à dériver d'un id émis par le serveur (panier, session de checkout) si le deuxième onglet doit être couvert.
  • En RxJS, l'opérateur d'une soumission est exhaustMap. Pas switchMap : annuler un POST en vol côté client n'annule rien côté serveur.

Le ticket qui ouvre la revue

Le support remonte un ticket : un client a reçu deux confirmations, deux débits, deux mails. Dans les logs, deux POST /orders identiques, 380 ms d'écart, même utilisateur. Et en daily, la phrase rituelle : "c'est pas possible, le bouton est disabled pendant l'envoi".

Le composant en cause ressemble à ça, et tu en as très probablement un équivalent quelque part dans ta codebase :

import { ChangeDetectionStrategy, Component, inject, signal } from '@angular/core';
import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
import { Router } from '@angular/router';
import { firstValueFrom } from 'rxjs';
import { OrderApi } from './order-api';

@Component({
  selector: 'app-checkout-form',
  imports: [ReactiveFormsModule],
  changeDetection: ChangeDetectionStrategy.OnPush,
  template: `
    <form [formGroup]="form" (ngSubmit)="save()">
      <input formControlName="email" type="email" />
      <button type="submit" [disabled]="submitting()" (click)="save()">
        Confirm order
      </button>
    </form>
  `,
})
export class CheckoutForm {
  private readonly api = inject(OrderApi);
  private readonly router = inject(Router);
  private readonly fb = inject(FormBuilder);

  readonly form = this.fb.nonNullable.group({
    email: ['', [Validators.required, Validators.email]],
  });
  readonly submitting = signal(false);

  async save() {
    const inStock = await firstValueFrom(this.api.checkStock());
    if (!inStock) return;

    this.submitting.set(true);
    this.api.createOrder(this.form.getRawValue()).subscribe({
      next: (order) => {
        this.submitting.set(false);
        this.router.navigate(['/orders', order.id]);
      },
    });
  }
}

Un [disabled], un flag submitting : tout a l'air sous contrôle. Il y a pourtant trois trous dans ce code, plus un quatrième qu'aucun composant ne peut boucher.

Trou 1 : un clic, deux appels

Regarde le bouton : type="submit" dans un form qui écoute (ngSubmit), et un (click) qui appelle la même méthode. Ce doublon arrive tout seul dans une vraie codebase : quelqu'un ajoute le (click) "pour être sûr", ou le form est arrivé après le bouton.

Le déroulé d'un seul clic : le navigateur dispatche click, save() tourne une première fois. Puis, action par défaut d'un bouton submit, le form est soumis, ngSubmit est émis, save() tourne une deuxième fois. Deux appels dans le traitement du même clic, pour un utilisateur parfaitement calme.

Et le [disabled] n'y change rien ici : le flag n'est posé qu'après l'await de checkStock(), le bouton est donc encore actif quand le navigateur soumet le form. Même un flag posé de façon synchrone ne suffirait pas en zoneless (le défaut depuis Angular 21) : le rendu qui grise le bouton est planifié après le traitement du clic. En zoneless, seule une garde dans le code bloque ce deuxième appel ; on y vient au trou 2.

La correction est triviale, c'est la repérer qui demande un œil exercé : un seul câblage de soumission par formulaire. Le form porte le (ngSubmit), le bouton porte type="submit" et rien d'autre.

<form [formGroup]="form" (ngSubmit)="save()">
  <button type="submit" [disabled]="submitting()">Confirm order</button>
</form>

Vérifie aussi les autres boutons du form : sans attribut type, un <button> est submit par défaut, et ton bouton "Annuler" soumet la commande.

Trou 2 : le flag posé après un await

Deuxième trou, plus sournois : save() commence par un await (ici un check de stock), et submitting n'est posé qu'après. Entre le clic et la résolution de checkStock(), il s'écoule un aller-retour réseau, facilement plusieurs centaines de millisecondes sur mobile. Pendant toute cette fenêtre, submitting() vaut false, le bouton est actif, et chaque clic supplémentaire lance un checkStock() puis un createOrder() de plus.

C'est la fenêtre des 380 ms du ticket : l'utilisateur n'a pas martelé le bouton, il a double-cliqué, geste que des années de bureautique lui ont appris.

La règle à appliquer en revue tient en une phrase : entre l'entrée dans le handler et la pose du flag, zéro await, zéro appel asynchrone. La garde et le flag sont les deux premières lignes, synchrones :

async save() {
  if (this.submitting()) return;
  this.submitting.set(true);

  let order: Order | null = null;
  try {
    const inStock = await firstValueFrom(this.api.checkStock());
    if (inStock) {
      order = await firstValueFrom(
        this.api.createOrder(this.form.getRawValue()),
      );
    }
  } catch {
    this.error.set('Order could not be confirmed. Check your orders before retrying.');
  }

  try {
    if (order) await this.router.navigate(['/orders', order.id]);
  } finally {
    this.submitting.set(false);
  }
}

Note bien le couple : la garde if (this.submitting()) return; et le flag. Le [disabled], lui, montre à l'utilisateur que c'est parti ; la garde protège, parce qu'une lecture de signal est synchrone et ne dépend d'aucun rendu. C'est elle qui aurait bloqué le deuxième appel du trou 1 : déclenché par le même clic, le deuxième save() lit un signal déjà à true et sort immédiatement.

Un bouton disabled sans garde, c'est une porte fermée par un panneau "fermé" : ça arrête les gens polis. Le try/finally, lui, n'est pas décoratif : sans lui, un checkStock() en échec laisserait le flag à true pour toujours - c'est le trou suivant. Et les deux try séparent deux portées qui ne coïncident pas : le flag couvre tout le flux, navigation comprise (sinon le bouton se réactive pendant une navigation lente et laisse passer une deuxième commande), quand le message d'erreur ne couvre que le check de stock et le POST, pas la navigation, dont l'échec survient sur une commande déjà créée.

Trou 3 : le flag jamais redescendu

Troisième trou, dans le subscribe du composant d'origine : submitting.set(false) ne vit que dans le next. Le jour où createOrder() répond 500, le flag reste à true, le bouton reste mort, l'utilisateur est coincé. Il recharge la page et recommence, ce qui, combiné au trou 4, peut à son tour finir en commande double.

La vraie raison de traquer ce trou en revue, c'est sa "correction" habituelle : six mois plus tard, quelqu'un tombe sur le ticket "le bouton reste grisé" et répare en retirant le [disabled]. La protection saute en silence, et personne ne reliera ça aux commandes doubles qui réapparaîtront trois sprints après.

La redescente du flag doit être inconditionnelle. En RxJS, c'est finalize :

this.api.createOrder(this.form.getRawValue())
  .pipe(finalize(() => this.submitting.set(false)))
  .subscribe({
    next: (order) => this.router.navigate(['/orders', order.id]),
    error: () => this.error.set('Order could not be confirmed. Check your orders before retrying.'),
  });

Le pattern à chercher en revue : un set(false) qui n'apparaît que sur le chemin de succès.

Trou 4 : ce que le client ne peut pas empêcher

Même avec les trois trous bouchés, ton composant ne protège que son propre onglet. Restent, vus en vraie prod :

  • Le deuxième onglet. Le même formulaire ouvert deux fois : deux instances, deux flags indépendants, deux soumissions légitimes du point de vue de chaque composant.
  • La réponse perdue. Le POST part, le serveur crée la commande, la réponse meurt dans un timeout. Côté client une erreur, l'utilisateur resoumet de bonne foi, côté serveur deux commandes.
  • Le retry d'interceptor. Vu en mission : un interceptor qui applique retry(2) à toutes les requêtes, POST compris. Chaque re-souscription est une vraie requête HTTP : sur un POST de paiement, c'est une machine à doublons. Un retry automatique ne se pose que sur des requêtes idempotentes, c'est-à-dire rejouables sans changer le résultat, GET en tête ; pour le régler endpoint par endpoint, passe par HttpContext.

Aucune garde de composant ne couvre ces trois cas (le retry d'interceptor, lui, se corrige aussi côté client : on ne rejoue pas les POST). La réponse robuste est côté API : une clé d'idempotence, convention popularisée par l'API de Stripe. Le client génère un identifiant unique par intention de soumission (la commande que l'utilisateur veut passer, quel que soit le nombre de requêtes nécessaires) et l'envoie dans un header ; le serveur stocke la clé à la première exécution et, s'il la revoit, renvoie le résultat déjà produit au lieu de réexécuter.

export class CheckoutForm {
  // one key per submission intent, see the two rules below
  private idempotencyKey = crypto.randomUUID();

  save() {
    if (this.submitting()) return;
    this.submitting.set(true);

    this.api.createOrder(this.form.getRawValue(), this.idempotencyKey)
      .pipe(finalize(() => this.submitting.set(false)))
      .subscribe({ /* ... */ });
  }
}
// order-api.ts
createOrder(payload: OrderPayload, idempotencyKey: string) {
  return this.http.post<Order>('/api/orders', payload, {
    headers: { 'Idempotency-Key': idempotencyKey },
  });
}

Trois règles de gestion. La clé survit à un échec : resoumettre après un timeout réutilise la même clé, le serveur dédoublonne. Elle est régénérée quand le payload change, pour ne pas envoyer deux commandes différentes sous la même clé. Et connais sa portée : générée à la construction du composant, elle couvre la resoumission après échec et le retry d'interceptor, pas le deuxième onglet ni le rechargement, qui créent une nouvelle instance et donc une nouvelle clé. Pour eux, dérive la clé d'un identifiant partagé émis par le serveur (id du panier ou de la session de checkout), ou pose une contrainte d'unicité métier : un panier ne donne qu'une commande.

Dernier détail : crypto.randomUUID() exige un contexte sécurisé, HTTPS ou localhost en dev.

Oui, ça demande du travail côté backend. Le critère : si un POST en double coûte de l'argent ou crée une donnée visible par le client, la clé n'est pas du luxe, c'est le filet.

La version RxJS : exhaustMap, et pourquoi switchMap est un faux ami

Si tes actions passent par un flux (un store, un service d'actions), le bon opérateur d'une soumission est exhaustMap : tant qu'une requête est en vol, les émissions suivantes sont ignorées. C'est la sémantique exacte d'un bouton submit.

export class CheckoutForm {
  // api, router, form, submitting, error, idempotencyKey: same members as above
  private readonly submitRequest$ = new Subject<OrderPayload>();

  constructor() {
    this.submitRequest$
      .pipe(
        exhaustMap((payload) =>
          this.api.createOrder(payload, this.idempotencyKey).pipe(
            finalize(() => this.submitting.set(false)),
            catchError(() => {
              this.error.set('Order failed. Retry.');
              return EMPTY;
            }),
          ),
        ),
        takeUntilDestroyed(),
      )
      .subscribe((order) => this.router.navigate(['/orders', order.id]));
  }

  save() {
    this.submitting.set(true);
    this.submitRequest$.next(this.form.getRawValue());
  }
}

Le réflexe switchMap, parfait pour une recherche, est ici un faux ami : il annule la requête précédente pour lancer la nouvelle. Sur un GET, très bien. Sur un POST, l'annulation côté client (abort de la requête HTTP) n'annule rien côté serveur : si la première requête est arrivée, elle sera traitée. Résultat possible : deux commandes exécutées, dont une que ton application n'a jamais observée. concatMap n'est pas mieux : il met la deuxième soumission en file et l'exécute après la première. Le même trio, appliqué à un upload où switchMap fait disparaître des fichiers sans erreur, est détaillé dans l'article sur la barre de progression.

exhaustMap est le seul des trois qui encode "ignore les clics tant que ça travaille". Avec lui, la garde if (this.submitting()) return; devient une ceinture de plus : le flux lui-même refuse toute nouvelle soumission tant que la précédente n'est pas terminée.

Récap actionnable

La checklist à dérouler en revue sur tout formulaire qui écrit quelque chose :

  1. Un seul câblage de soumission : (ngSubmit) sur le form, type="submit" sur le bouton, aucun (click) doublon. Et un type explicite sur chaque bouton du form.
  2. Garde synchrone en tête de handler : if (this.submitting()) return; puis submitting.set(true), avant le moindre await.
  3. Redescente inconditionnelle du flag : finalize ou try/finally. Un set(false) qui ne vit que dans le next est un bouton mort en sursis, et un futur "fix" qui supprimera le disabled.
  4. Flux RxJS : exhaustMap pour une soumission. switchMap annule côté client mais pas côté serveur, concatMap sérialise les doublons.
  5. Pas de retry() automatique sur des requêtes non idempotentes. Un interceptor qui retry tout est un générateur de doublons.
  6. Clé d'idempotence pour tout POST dont le doublon coûte : header Idempotency-Key, clé par intention de soumission, conservée après échec, régénérée quand le payload change, dérivée d'un identifiant partagé émis par le serveur (panier, session) si le deuxième onglet doit être couvert.

Les exemples utilisent les signals, inject() et des composants standalone par défaut : ils compilent tels quels à partir d'Angular 19 ; en 17 ou 18, ajoute standalone: true au décorateur. Si tu es sur Signal Forms (Angular 22), submit() pose submitting() de façon synchrone, refuse une soumission concurrente et redescend le flag dans tous les cas : les trous 1 à 3 sont couverts d'office, tant que tout le travail asynchrone (le check de stock compris) vit dans l'action de soumission et y est attendu avec await - un await oublié dans l'action est un des pièges de l'article de migration. Le trou 4, lui, reste entièrement ton problème.

Le fond de l'affaire, c'est que "le bouton est disabled" décrit un pixel, pas une garantie. La garantie, c'est une garde synchrone (ou exhaustMap si tu passes par un flux) qui ignore les clics tant que la requête est en vol, un flag qui redescend quoi qu'il arrive, et un serveur capable de reconnaître une clé déjà vue. Trois couches, parce que chacune couvre un cas que les autres ne voient pas.

📧 Reste informé(e) !

Reçois les derniers articles et conseils EasyAngularKit directement dans ta boîte mail.

S'inscrire gratuitement

AngularKit

Suite d'outils pour développeurs Angular francophones. Apprends, modernise tes réflexes, audite ta codebase.

Produits

Contact

Légal

© 2026 AngularKit. Tous droits réservés.