Aller au contenu
English

État local et état serveur

  • Leçon 8
  • 50 min
  • Module 3 : Récupération des données et gestion de l'état

Où nous en sommes

Dans le module 2, nous avons construit le bureau avec des composants, et un effet avec nettoyage a empêché une ancienne réponse d'en remplacer une nouvelle. Mais le bureau oublie ce qu'il a récupéré : revenir à un billet interroge de nouveau l'API. Et certaines valeurs appartiennent à l'agent, d'autres au serveur. Dans cette leçon, nous séparons ces deux types d'état, et un cache garde les données du serveur. Pensez à votre propre carnet et au tableau d'affichage du bureau.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Certaines valeurs à l’écran appartiennent à l’agent, d’autres à l’API des billets de soutien. Gardez-les séparées pour simplifier les choix de l’agent. Les données de l’API sont ainsi récupérées une seule fois, partagées et actualisées quand elles deviennent anciennes.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 50 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Node.js 24 (LTS), VS Code, un terminal et Chrome, Edge ou Firefox.
  • Votre dossier ticket-desk à la fin du module 2. Son npm test se termine par Tests 14 passed (14) (14 tests réussis), après les 21 vérifications de l’API simulée.
  • Une connexion Internet pour exécuter npm install une fois dans cette leçon.

Si votre projet ne fonctionne pas, repartez de l’instantané end-of-m02 du dépôt des exercices. Copiez le dossier nextia-learning-labs/C22/snapshots/end-of-m02 dans ticket-desk, puis exécutez npm install dans ce dossier.

Testé avec Node.js 24.18.0 et npm 11.16.0 sur macOS (Apple silicon), dans Chromium. Les commandes Windows et Linux sont rédigées, mais n’ont pas été testées.

Imaginez un bureau avec un tableau d’affichage dans le couloir. Le tableau indique les heures d’ouverture, la liste des numéros de téléphone et le calendrier des vacances. Tout le monde le consulte, et la personne responsable du bureau le modifie quand quelque chose change.

Vous avez aussi votre propre carnet. Vous y notez la page que vous lisez, quelques remarques et une liste de choses à faire. Personne d’autre ne peut modifier votre carnet. Il décrit donc toujours correctement votre propre travail.

Quand vous avez besoin de la liste des numéros de téléphone à votre bureau, vous la copiez dans votre carnet. Cette copie vous évite d’aller au couloir chaque fois. Mais la copie a un âge. Si la personne responsable ajoute un numéro demain, votre copie ne change pas. Une personne attentive inscrit la date à côté de la copie et retourne au tableau quand elle devient ancienne.

Le problème : le bureau oublie les données récupérées

Section intitulée « Le problème : le bureau oublie les données récupérées »

Le bureau des billets contient ces deux types d’information. Pourtant, à la fin du module 2, il les conserve de la même façon. Chaque valeur se trouve dans l’état React. Le texte de recherche est un état dans TicketList. Le billet que l’agent a ouvert se trouve dans l’adresse, #/tickets/T-80008. Les données du billet provenant de l’API sont aussi un état, dans notre hook useApi.

useApi traite le billet comme le texte de recherche : comme une information propre au composant. Quand le composant affiche un autre billet, useApi supprime les anciennes données. Quand l’agent revient, il interroge l’API de nouveau. L’équipe du cours a compté les requêtes dans un vrai navigateur, avec la version de production du bureau :

Ce que fait l’agent Requêtes de billets jusqu’ici
Ouvre le bureau sur T-80008 1
Ouvre T-80007 2
Revient à T-80008 quelques secondes plus tard 3

Sur votre ordinateur, l’API simulée répond en environ une milliseconde. Vous ne voyez donc pas l’attente. Sur un réseau mobile, chaque requête entraîne une attente. L’équipe du cours a aussi simulé un réseau mobile, avec 150 ms pour chaque aller-retour au serveur. Le bureau y affichait « Loading T-80008… » (chargement de T-80008…) pendant 158 ms quand l’agent revenait. Il avait affiché ce billet quelques secondes auparavant.

Le deuxième problème est plus grave. Supposons qu’un autre agent passe le statut de T-80008 à pending (en attente) pendant que vous le lisez. Votre écran indique encore Open (ouvert). useApi a récupéré le billet une seule fois, à son ouverture, et ne le demande jamais de nouveau. Rien à l’écran n’indique l’âge des données. Vous pouvez essayer vous-même le cas de défaillance à la fin de cette leçon.

Les deux problèmes ont la même cause. Le billet n’est pas une information propre au composant. C’est une copie de données qui appartiennent à l’API des billets.

Les développeurs React donnent deux noms à ces deux types d’information.

L’état local correspond aux choix de l’agent à l’écran : texte de recherche, filtre de statut, billet ouvert et réponse en cours. Cet onglet du navigateur en est le seul propriétaire. Il est toujours exact, car personne d’autre ne peut le modifier. C’est le carnet.

L’état serveur correspond aux données que l’API des billets conserve : les billets, leurs messages et leur statut. L’API en est propriétaire, et d’autres agents peuvent les modifier à tout moment. Le navigateur n’en a jamais qu’une copie. Obtenir cette copie prend du temps, la requête peut échouer et la copie devient ancienne. C’est le tableau d’affichage. Le nom indique où se trouve la vraie valeur : sur le serveur.

Un cache conserve ces copies. Chaque copie a un nom, appelé sa clé, et une heure de récupération. L’écran demande une copie au cache à l’aide de sa clé. Si le cache contient une copie assez récente, l’écran l’obtient immédiatement, sans requête. Sinon, le cache la récupère depuis l’API et la conserve. Il la fournit à chaque composant qui demande la même clé.

Trois panneaux. État local, appartenant à cet onglet du navigateur : texte de recherche parcel, filtre de statut all, billet ouvert T-80008 dans l'adresse, réponse en cours de rédaction; toujours exact, personne d'autre ne peut le modifier. Le cache : copies des données du serveur, chacune avec un nom et un âge : détail du billet T-80008 récupéré il y a 4 secondes, à jour; liste des billets parcel récupérée il y a 40 secondes, périmée; une copie peut être ancienne. État serveur, appartenant à l'API des billets : billets, messages, statut de T-80008; d'autres agents le modifient à tout moment. Flèches : GET de l'état serveur vers le cache, ce qui prend du temps et peut échouer; useState et l'adresse de l'état local vers l'écran; useQuery du cache vers l'écran; PATCH et POST, une modification, de l'écran vers le serveur.
L'écran lit les choix de l'agent dans l'état local et les copies des données de l'API dans le cache. Seule l'API détient la vraie valeur de l'état serveur.
Description textuelle du diagramme

Le diagramme contient trois panneaux et une boîte pour l’écran. Le panneau vert représente l’état local, qui appartient à cet onglet du navigateur. Il contient le texte de recherche « parcel » (colis), le filtre de statut, le billet ouvert T-80008 (dans l’adresse) et une réponse en cours de rédaction. Personne d’autre ne peut le modifier. Le panneau bleu représente l’état serveur, qui appartient à l’API des billets : les billets, leurs messages et le statut de T-80008. D’autres agents le modifient à tout moment. Entre les deux, le panneau jaune représente le cache : des copies des données du serveur, chacune avec un nom et un âge. Le billet T-80008 a été récupéré il y a 4 secondes et est à jour. La liste pour « parcel » a été récupérée il y a 40 secondes et est périmée. Une flèche du serveur vers le cache indique qu’un GET prend du temps et peut échouer. L’écran lit l’état local avec useState et l’adresse, et le cache avec useQuery. Une flèche pointillée de l’écran vers le serveur représente une modification : un PATCH ou un POST.

Regardez le bureau avec T-80008 ouvert et posez une question pour chaque valeur : une autre personne pourrait-elle la modifier? Si oui, c’est un état serveur.

Valeur à l’écran Où se trouve sa vraie valeur Type
Le texte du champ de recherche, « parcel » cet onglet local
Le filtre de statut, « All » (tous) cet onglet local
Le billet ouvert, T-80008 l’adresse de cet onglet local
Le texte d’une réponse que l’agent n’a pas encore envoyée cet onglet local
L’objet de T-80008, « Hello, where is my order LK-581106? » (bonjour, où est ma commande LK-581106?) l’API des billets serveur
Le statut de T-80008, « Open » l’API des billets serveur
Les 50 billets de la liste l’API des billets serveur
« Loading T-80008… » nulle part : il vient de la requête dérivé

Deux lignes méritent un second regard. La réponse reste locale pendant que l’agent la rédige. Quand l’agent l’envoie, elle devient un message sur le serveur. Elle fait alors partie de l’état serveur. Les mots « Loading T-80008… » ne sont pas conservés du tout. Ils découlent de l’état d’une requête, comme une valeur dérivée découle d’autres valeurs dans Rendu et effets.

Vous pourriez écrire le cache vous-même. Notre useApi annule déjà une ancienne requête lors de son nettoyage. Mais un cache exige beaucoup plus : une clé et un âge pour chaque copie. Il faut une seule requête quand deux composants demandent la même clé. Il faut aussi actualiser les copies anciennes et pouvoir les marquer comme anciennes après une modification. Cela demande beaucoup de code soigneusement écrit.

TanStack Query est une bibliothèque gratuite qui fait ce travail (licence MIT). Le cours utilise la version 5.104.1. L’équipe du cours a mesuré ce qu’elle apporte au bureau, par rapport à useApi :

  • Le cache : revenir à un billet dans les 30 secondes n’envoie aucune requête.
  • Marquer les copies comme anciennes après une modification, pour que l’écran affiche les nouvelles données. Vous ajoutez cela dans Cycle de vie d’une requête.
  • L’annulation : pendant qu’un agent tapait « parcel », 5 des 6 requêtes de liste ont été interrompues.
  • Des nouvelles tentatives qui attendent aussi longtemps que l’indique l’en-tête Retry-After de l’API.

Cela ajoute 13,6 ko de JavaScript après compression gzip : 9,5 ko pour son noyau et 4,1 ko pour sa partie React. À titre de comparaison, react-dom de React occupe 64,1 ko.

Vous devez connaître quatre noms de TanStack Query dans cette leçon :

  • Le client de requêtes est le cache. L’application en possède un.
  • useQuery demande une copie au cache. Il prend une clé et une fonction.
  • La clé de requête est le nom de la copie : un tableau comme ['tickets', 'detail', 'T-80008']. Deux composants qui utilisent la même clé partagent une seule copie.
  • La fonction de requête indique comment récupérer la copie quand le cache n’en a aucune : ici, getTicket('T-80008').

Le cache a aussi besoin d’une règle pour l’âge d’une copie. Le bureau définit cette règle : une copie est considérée comme à jour pendant 30 secondes. Pendant ce temps, le cache la fournit à l’écran sans requête. Après 30 secondes, la copie est périmée. Le cache la récupère de nouveau la prochaine fois qu’un écran en a besoin. La prochaine leçon suit une copie pendant tout son cycle de vie.

Vous modifiez quatre fichiers. La liste reste telle quelle dans cette leçon; vous la déplacez dans le cache dans la prochaine.

  1. Ouvrez un terminal dans votre dossier ticket-desk. Si npm run dev y est en cours, arrêtez-le avec Ctrl+C. Installez ensuite la bibliothèque avec la version exacte :

    Fenêtre de terminal
    npm install @tanstack/react-query@5.104.1 --save-exact

    La sortie sur le portable de l’équipe du cours :

    added 2 packages, and audited 107 packages in 1s
    23 packages are looking for funding
    run `npm fund` for details
    found 0 vulnerabilities

    npm 11 peut aussi afficher quatre lignes qui commencent par npm warn allow-scripts et nomment fsevents. Ce paquet est un outil facultatif de surveillance des fichiers pour macOS, utilisé par Vite. Ce cours ne vous demande pas de l’approuver; vous pouvez donc ignorer l’avertissement. package.json contient maintenant "@tanstack/react-query": "5.104.1" sous dependencies. Changez sa "version" pour "0.3.0" : ce module marque une nouvelle étape du projet.

  2. Créez le fichier src/api/queryClient.ts. Il crée le cache et contient ses règles. Il va dans api/, car les règles du cache font partie des échanges entre le bureau et l’API.

    src/api/queryClient.ts
    // The cache of server data (TanStack Query) and its rules for this app.
    import { QueryClient } from '@tanstack/react-query';
    export function makeQueryClient(): QueryClient {
    return new QueryClient({
    defaultOptions: {
    queries: {
    staleTime: 30_000, // an answer counts as fresh for 30 s: no new request in that time
    gcTime: 5 * 60_000, // an answer that no screen uses stays in the cache for 5 minutes
    },
    },
    });
    }

    staleTime représente les 30 secondes pendant lesquelles la copie est à jour, en millisecondes. gcTime indique combien de temps le cache garde une copie qu’aucun écran n’affiche. « gc » signifie garbage collection (ramasse-miettes) : supprimer ce que personne n’utilise.

  3. Donnez un seul cache à toute l’application. Dans src/main.tsx, entourez <App /> d’un QueryClientProvider. Un fournisseur est un composant qui rend une valeur accessible à tous les composants qu’il contient.

    src/main.tsx
    import { StrictMode } from 'react';
    import { createRoot } from 'react-dom/client';
    import { QueryClientProvider } from '@tanstack/react-query';
    import { App } from './App';
    import { makeQueryClient } from './api/queryClient';
    import './styles.css';
    const queryClient = makeQueryClient();
    createRoot(document.getElementById('root')!).render(
    <StrictMode>
    <App />
    <QueryClientProvider client={queryClient}>
    <App />
    </QueryClientProvider>
    </StrictMode>,
    );

    Le cache est créé une seule fois, en dehors des composants. Si vous le créiez dans App, React pourrait créer un nouveau cache vide à chaque nouveau rendu d’App.

  4. Créez src/features/tickets/queries.ts. Il contient l’état serveur des billets : les clés et les hooks qui les lisent.

    src/features/tickets/queries.ts
    // Server state of the tickets: the cache keys and the queries.
    import { useQuery } from '@tanstack/react-query';
    import { getTicket } from '../../api/tickets';
    /** One place for the cache keys: every key of the tickets starts with 'tickets'. */
    export const ticketKeys = {
    all: ['tickets'] as const,
    detail: (id: string) => [...ticketKeys.all, 'detail', id] as const,
    };
    export function useTicket(id: string) {
    return useQuery({ queryKey: ticketKeys.detail(id), queryFn: ({ signal }) => getTicket(id, signal) });
    }

    Les clés sont créées au même endroit. Une faute de frappe ne peut donc pas créer un deuxième nom pour la même copie. signal est le même type d’AbortSignal que celui utilisé par useApi. TanStack Query annule la requête quand personne n’a plus besoin de sa réponse.

  5. Dans src/features/tickets/TicketView.tsx, lisez le billet depuis le cache plutôt qu’avec useApi :

    src/features/tickets/TicketView.tsx
    import { getTicket } from '../../api/tickets';
    import { useApi } from '../../lib/useApi';
    import { ErrorMessage } from '../../ui/ErrorMessage';
    import { StatusBadge } from '../../ui/StatusBadge';
    import { useTicket } from './queries';
    /** One ticket: the customer's message and the conversation. */
    export function TicketView({ ticketId }: { ticketId: string }) {
    const ticket = useApi((signal) => getTicket(ticketId, signal), [ticketId]);
    const ticket = useTicket(ticketId);
    if (ticket.status === 'loading') return <p className="muted">Loading {ticketId}…</p>;
    if (ticket.status === 'error') return <ErrorMessage error={ticket.error} />;
    if (ticket.isPending) return <p className="muted">Loading {ticketId}…</p>;
    if (ticket.isError) return <ErrorMessage error={ticket.error} onRetry={() => ticket.refetch()} />;
    const t = ticket.data;

    isPending est vrai tant que le cache n’a pas encore de copie. refetch() récupère la copie de nouveau. Le message d’erreur peut donc maintenant proposer Try again (réessayer). Le reste du composant ne change pas.

  6. Exécutez les vérifications :

    Fenêtre de terminal
    npm test

    Les 21 vérifications de l’API simulée réussissent d’abord. Ensuite, Vitest affiche :

    Test Files 6 passed (6)
    Tests 14 passed (14)

    Ce sont les mêmes 14 tests qu’avant : l’écran se comporte comme auparavant. Seule la provenance des données a changé.

  1. Dans le premier terminal, démarrez l’API simulée : npm run api.
  2. Dans un deuxième terminal, démarrez le bureau : npm run dev. Ouvrez http://localhost:5173/#/tickets/T-80008.
  3. Ouvrez les outils de développement du navigateur (F12, ou Cmd+Option+I sur Mac), puis choisissez le panneau Network (réseau). Tapez v1/tickets/T dans son champ de filtre pour afficher seulement les requêtes de billets.
  4. Cliquez sur T-80007 dans la liste, puis de nouveau sur T-80008.

Le panneau Network affiche deux requêtes de billets ayant reçu une réponse : une pour T-80008 et une pour T-80007. Le retour à T-80008 n’a rien envoyé, car la copie avait moins de 30 secondes. Au tout début, vous voyez aussi une requête pour T-80008 marquée comme annulée. En développement, StrictMode de React affiche chaque composant deux fois à sa première apparition pour trouver des erreurs. La version de production ne le fait pas. L’écran ressemble à celui d’avant :

Le bureau des billets dans le navigateur. À gauche, la liste Tickets (billets) avec un champ de recherche, les filtres Status (statut) et Team (équipe), le texte Showing 50 tickets (50 billets affichés) et des lignes comme T-80010, T-80009 et T-80008, qui est en surbrillance. À droite, le billet T-80008 de Tariq Jensen, shipping (expédition), priorité 2, avec l'objet Hello, where is my order LK-581106?, l'étiquette Open et le message du client.
Le bureau à la fin de cette leçon, sur T-80008. Rien n'a changé à l'écran : le billet vient maintenant du cache. L’image est en anglais.

L’équipe du cours a compté les requêtes des deux versions du bureau dans Chromium, sur un réseau rapide et un réseau mobile simulé :

  • Notre hook useApi
  • Le cache (TanStack Query)
Going back to a ticket: three requests with useApi, two with the cache. On the phone-like network, useApi showed "Loading T-80008…" for 158 ms when the agent went back; the cache showed the ticket at once.
Description textuelle du graphique

Un graphique à colonnes avec quatre colonnes. Sur une connexion rapide, notre hook useApi a envoyé 3 requêtes de billets pour les trois étapes. Le cache en a envoyé 2. Sur un réseau mobile simulé (150 ms par aller-retour), les nombres sont 3 et 2. La différence vient de la troisième étape, le retour à T-80008 : le cache avait une copie à jour. Avec useApi, l’agent a vu « Loading T-80008… » pendant 158 ms sur le réseau mobile simulé.

Tout ne passe pas dans le cache. Trois éléments restent où ils sont, chacun pour une raison.

  • Le texte de recherche et les filtres restent dans useState, dans TicketList. Ce sont les choix de l’agent, et aucun serveur ne les connaît.
  • Le billet ouvert reste dans l’adresse. L’adresse est un état local que le navigateur conserve pour vous : elle survit au rechargement. L’agent peut aussi partager le lien avec un collègue.
  • La réponse que l’agent rédige sera dans useState, dans un formulaire. Elle devient un état serveur seulement quand l’API l’enregistre, dans Pagination et formulaires.

Tomás, l’ingénieur en IA, propose un raccourci : « Mettons tout dans un seul grand magasin d’état pour l’application : les billets, la recherche, les menus ouverts. Comme ça, chaque composant peut tout lire. » Teodor demande ce que cela coûterait. Un magasin d’état ne sait pas quelles valeurs sont des copies. Il ne peut donc pas savoir quand une valeur est périmée. Vous devriez gérer vous-même l’âge, l’actualisation et l’annulation de chaque copie. Amira, responsable de l’API des billets, résume en une phrase : « Gardez vos choix simples, et mes données dans un cache qui sait qu’il conserve une copie. »

Utilisez un cache d’état serveur quand l’écran affiche des données qui appartiennent à un serveur. Il est utile si plusieurs écrans ou plusieurs visites ont besoin des mêmes données. Le bureau est un bon exemple. Les agents passent d’un billet à l’autre toute la journée. La liste et la vue d’un billet affichent les mêmes billets.

Vous n’en avez pas besoin pour une petite page qui récupère un seul élément, une seule fois. C’est le cas de la première page du module 1. Et ne mettez jamais l’état local dans le cache : aucun serveur ne peut actualiser un texte de recherche.

Le cache a des coûts :

  • 13,6 ko de JavaScript après compression gzip, et une bibliothèque de plus à tenir à jour.
  • De nouveaux mots à apprendre : clés, à jour, périmé, invalidation.
  • Une copie peut être périmée volontairement. Pendant 30 secondes, le bureau peut afficher un statut qu’un autre agent a déjà changé. Vous choisissez cette durée pour chaque type de données. Pour une liste de billets, 30 secondes sont acceptables. Pour un paiement, ce ne serait pas le cas.

À vous de jouer : aussitôt reçue, aussitôt périmée

Section intitulée « À vous de jouer : aussitôt reçue, aussitôt périmée »

Changez un réglage. Dans src/api/queryClient.ts, définissez staleTime: 0. Chaque copie devient alors périmée dès son arrivée. Avant d’essayer, faites une prédiction : quand vous revenez à T-80008, l’écran affiche-t-il « Loading T-80008… » (chargement de T-80008…)? Combien de requêtes de billets le panneau Network (réseau) affiche-t-il pour les trois étapes?

Afficher la réponse

L’essai de l’équipe du cours avec staleTime: 0 a envoyé 3 requêtes de billets, autant qu’avec useApi. Mais sur le réseau téléphonique simulé, « Loading T-80008… » s’est affiché pendant 0 ms au retour de l’agent, contre 158 ms avec useApi.

Le cache reste donc utile. Il ne jette pas une copie périmée. Il l’affiche immédiatement et récupère une nouvelle copie en arrière-plan. Quand la nouvelle copie arrive, l’écran s’affiche de nouveau. Ce comportement s’appelle stale-while-revalidate : afficher la copie périmée pendant qu’on la vérifie de nouveau. staleTime détermine quand le cache interroge de nouveau le serveur, pas si l’agent doit attendre.

Remettez staleTime à 30_000 avant de continuer.

Erreur courante

Le statut a changé, mais pas l'écran

Symptôme : vous consultez T-80008 dans le bureau. Un autre agent le passe à pending (en attente). Votre écran affiche toujours Open (ouvert), et rien ne vous indique que les données sont périmées.

Essayez avec la version du bureau du module 2 (l’instantané end-of-m02), qui utilise useApi. Ouvrez http://localhost:5173/#/tickets/T-80008. Dans un terminal, jouez le rôle de l’autre agent :

Fenêtre de terminal
curl -X PATCH http://127.0.0.1:8100/v1/tickets/T-80008 -H "Content-Type: application/json" -d '{"status": "pending"}'

L’équipe du cours a fait cet essai dans les deux versions du bureau et a lu l’étiquette du billet ouvert. « Revient » signifie que l’agent passe à une autre fenêtre, puis revient au navigateur :

Après le changement useApi (module 2) Le cache (cette leçon)
0.2 s : l’API a le nouveau statut Open Open
0.7 s : l’agent revient immédiatement Open Open
31.8 s : l’agent revient après plus de 30 s Open Pending

Cause : useApi traite le billet comme un état propre au composant. Il le récupère une fois, à l’ouverture du billet, et ne sait pas que la copie devient périmée.

Solution : gardez l’état serveur dans le cache. Quand la fenêtre du navigateur reprend le focus, TanStack Query récupère chaque copie périmée affichée à l’écran. Pendant les 30 secondes, la copie est considérée comme à jour. L’étiquette reste donc Open : c’est le coût de staleTime. La prochaine leçon ajoute l’autre solution : après une modification faite dans le bureau, celui-ci marque immédiatement les copies comme périmées.

Conséquence pour le travail en IA : un brouillon d’IA, un statut de tâche ou un indicateur « intervention humaine nécessaire » sont aussi des états serveur. Ils changent pendant que l’agent regarde l’écran. Une copie jamais actualisée peut amener un agent à envoyer une réponse qu’un collègue a déjà envoyée.

Vérifiez votre compréhension

Classez ces valeurs de l'écran de création d'un billet en état local ou état serveur. Justifiez chaque choix : l'identifiant client que l'agent saisit, la liste des équipes du filtre Team (équipe), l'identifiant du billet renvoyé par l'API après l'envoi du formulaire, les mots « Sending… » (envoi en cours…) sur le bouton.

Afficher la réponse
  • L’identifiant client en cours de saisie : local. Seul cet onglet le connaît jusqu’à l’envoi du formulaire.
  • La liste des équipes : ni l’un ni l’autre, pour l’instant. Le bureau utilise une liste fixe dans api/types.ts (TEAMS), tirée du contrat de l’API. Si l’API pouvait ajouter des équipes, la liste serait un état serveur, récupéré et mis en cache comme les billets.
  • L’identifiant du billet renvoyé par l’API : état serveur. L’API l’a créé et possède le billet. L’écran affiche une copie de la réponse.
  • « Sending… » : valeur dérivée. Elle découle de l’état de la requête; elle n’est pas stockée comme une valeur distincte.

Le test pour chaque valeur : une autre personne, ou le serveur, pourrait-elle la changer? Si oui, c’est un état serveur.

Vérifiez votre compréhension

Faites une prédiction : avec staleTime à 30 s, un agent ouvre T-80008, puis T-80007. Il revient à T-80008 après 10 secondes, puis à T-80007 après 2 minutes. Combien de requêtes de billets le bureau envoie-t-il? L'agent voit-il « Loading… » (chargement…) pour un billet déjà ouvert auparavant?

Afficher la réponse

Trois requêtes. T-80008 et T-80007 sont récupérés une fois chacun. Le retour à T-80008 après 10 secondes utilise la copie à jour : aucune requête. Après 2 minutes, la copie de T-80007 est périmée. Le cache la récupère donc de nouveau : c’est la troisième requête.

L’agent ne voit jamais « Loading… » pour un billet déjà ouvert auparavant. Le cache conserve une copie inutilisée pendant 5 minutes (gcTime). Il affiche immédiatement une copie périmée pendant le chargement de la nouvelle. Seul un billet jamais ouvert, ou fermé depuis plus de 5 minutes, affiche « Loading… ».

Récapitulatif

  • L’état local représente les choix de l’agent : texte de recherche, filtres, billet ouvert, réponse en cours de rédaction. Il appartient à cet onglet et il est toujours exact.
  • L’état serveur représente les données de l’API : billets, messages, statut. Le navigateur n’a qu’une copie. Sa récupération prend du temps, peut échouer, et la copie devient périmée. Pour chaque valeur, demandez-vous : quelqu’un d’autre pourrait-il la changer?
  • Un cache conserve des copies sous une clé, avec leur âge. Le bureau utilise TanStack Query (13,6 ko avec gzip) : un client de requêtes dans main.tsx, les clés dans queries.ts, et useTicket dans TicketView.
  • Avec useApi, revenir à un billet envoyait une troisième requête. Avec le cache, une copie de moins de 30 secondes (staleTime) s’affiche sans requête. Une copie plus ancienne s’affiche immédiatement pendant le chargement d’une nouvelle copie.
  • Une copie jamais actualisée affiche un ancien statut. Le cache récupère de nouveau les copies périmées quand la fenêtre reprend le focus.

Ensuite, vous suivez une copie tout au long de sa vie : à jour, périmée, récupérée de nouveau, marquée comme périmée après une modification, annulée, puis récupérée après une nouvelle tentative. Vous déplacez aussi la liste dans le cache.

Leçon suivante : Cycle de vie d'une requête