Formations — 1 037 leçons en français

Accueil › TypeScript › Typer une API Node

Typer une API Node

TypeScript avec React et Nodeavance

Les types de TypeScript disparaissent à la compilation. Un serveur Node reçoit donc du JSON analysé — un objet quelconque — et aucun framework ne vérifie ce que vous avez déclaré.

type CreerCommande = { clientId: string; quantite: number };

app.post("/commandes", (req, res) => {
  const corps = req.body as CreerCommande;   // ❌ promesse non tenue
  const total = corps.quantite * PRIX;       // NaN si le client envoie "trois"
});

L'assertion n'inspecte rien. Le type est une déclaration d'intention, et c'est tout.

La seule façon de la rendre vraie

type Resultat<T> = { ok: true; valeur: T } | { ok: false; erreurs: string[] };

function lireCreerCommande(v: unknown): Resultat<CreerCommande> {
  if (typeof v !== "object" || v === null) return { ok: false, erreurs: ["corps"] };
  const o = v as Record<string, unknown>;
  const erreurs: string[] = [];
  if (typeof o.clientId !== "string") erreurs.push("clientId");
  if (typeof o.quantite !== "number" || !Number.isInteger(o.quantite))
    erreurs.push("quantite");
  if (erreurs.length > 0) return { ok: false, erreurs };
  return { ok: true, valeur: { clientId: o.clientId as string, quantite: o.quantite as number } };
}

app.post("/commandes", (req, res) => {
  const lu = lireCreerCommande(req.body);
  if (!lu.ok) return res.status(400).json({ erreurs: lu.erreurs });
  enregistrer(lu.valeur);          // ici seulement, le type est vrai
});

C'est le même mensonge qu'un fetch générique

async function recuperer<T>(url: string): Promise<T> {
  return (await fetch(url)).json() as Promise<T>;
}

T est choisi par l'appelant, et rien ne le confronte au corps reçu. Côté client comme côté serveur, un type à la frontière sans validation est faux.

Les termes à connaître

Frontière

Le point où une donnée entre dans le programme sans venir de lui : corps de requête, paramètres d'URL, variables d'environnement, réponse d'un service tiers. Tout type posé là est une déclaration, pas une garantie.

Annotation non vérifiée

req.body as Commande ou Request<…, CreerCommande> : le framework ne contrôle rien. Le type dit ce qu'on espère recevoir.

Validation à l'exécution

Une fonction qui inspecte la donnée reçue et rejette ce qui ne correspond pas. C'est le seul moyen de rendre un type vrai à la frontière.

Garde de type

function estCommande(v: unknown): v is Commande. Elle lie une vérification d'exécution à un affinage de type — c'est le pont entre les deux mondes.

@types/node et @types/express

Les typages ne sont pas livrés avec ces paquets : ils viennent de paquets séparés, et leur version doit suivre celle de l'exécution utilisée.

unknown à l'entrée

Typer une entrée externe en unknown au lieu de any force à valider avant d'utiliser. C'est le réglage par défaut le plus rentable sur un serveur.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.