Modéliser les types métier en TypeScript avec des unions discriminées

Prompt

Agis comme un expert de TypeScript et de la conception guidée par les types, qui privilégie la clarté aux astuces.

Contexte :
- Domaine : {{domaine}}
- Types actuels (le cas échéant) : {{types_actuels}}
- Où ils sont utilisés : {{usage}}

S'il n'est pas clair quelles transitions entre états sont valides ou quels champs existent dans chaque état, demande-le-moi avant de concevoir.

Livrables :
1. Un diagnostic des types actuels : quelles combinaisons impossibles ils autorisent (par exemple une commande « expédiée » sans date d'expédition) et quels bugs cela peut provoquer.
2. Le nouveau modèle : unions discriminées par un champ littéral, champs présents seulement dans l'état concerné, `readonly` quand c'est pertinent et types de marque pour les identifiants à ne pas confondre.
3. Des fonctions de transition typées qui n'acceptent que l'état d'origine valide.
4. Un `switch` exhaustif avec vérification `never`, et un exemple de l'erreur de compilation qui apparaît quand on ajoute un état sans le traiter.
5. Une validation aux frontières du système (API, formulaires, stockage) avec un schéma dont le type est dérivé, pour que type et validation ne divergent pas.
6. Des tests de types avec `@ts-expect-error` ou `expectTypeOf` qui prouvent que les états impossibles ne compilent pas.
7. Les cas où ce modèle est excessif et où plus simple suffirait.

Contraintes :
- Préfère les unions de littéraux aux `enum`, sauf si tu expliques pourquoi un enum convient mieux.
- Pas de types conditionnels ni de génériques complexes sans bénéfice clair ; un développeur intermédiaire doit pouvoir lire le code.
- N'invente pas de règles métier : marque celles que je dois confirmer avec [À COMPLÉTER].

Format : diagnostic, blocs de code avec nom de fichier et tableau des états et transitions.

Comment l'utiliser

Exemple d'utilisation

Exemple de résultat

export type CommandeId = string & { readonly __marque: 'CommandeId' };

type Base = { readonly id: CommandeId };

export type Commande =
  | (Base & { statut: 'en_attente' })
  | (Base & { statut: 'payee'; payeeLe: Date })
  | (Base & { statut: 'expediee'; payeeLe: Date; numeroSuivi: string })
  | (Base & { statut: 'livree'; payeeLe: Date; numeroSuivi: string })
  | (Base & { statut: 'annulee'; motifAnnulation: string });

type AuStatut<S extends Commande['statut']> = Extract<Commande, { statut: S }>;

export function expedier(commande: AuStatut<'payee'>, numeroSuivi: string): AuStatut<'expediee'> {
  return { ...commande, statut: 'expediee', numeroSuivi };
}

export function libelle(commande: Commande): string {
  switch (commande.statut) {
    case 'en_attente': return 'En attente de paiement';
    case 'payee': return 'Payée';
    case 'expediee': return `Expédiée (${commande.numeroSuivi})`;
    case 'livree': return 'Livrée';
    case 'annulee': return `Annulée : ${commande.motifAnnulation}`;
    default: {
      const exhaustif: never = commande;
      return exhaustif;
    }
  }
}

Informations clés

Catégorie

Programmation et développement · TypeScript

Type de résultat

Code

Niveau

Avancé

Conçu pour

ChatGPT, Claude, Gemini et Microsoft Copilot

Vérifié sur

En attente de vérification éditoriale

Variables

Domaine, Types actuels et Où ils sont utilisés

Langue

Français

Prix

Gratuit, sans inscription

Mis à jour

07/11/2026

Questions fréquentes