Qu'est-ce que le problème N+1 en GraphQL et comment DataLoader le résout-il ?

Question

IT Interview Practice · Accepted Answer

Le **problème N+1** survient lorsqu'un resolver de champ s'exécute une fois par élément parent et que chaque exécution émet sa propre requête en base. Récupérer une liste de N posts, puis l'auteur de chaque post, déclenche **1 requête pour les posts + N requêtes pour les auteurs** — N+1 allers-retours qui écroulent les performances en charge.

## Pourquoi cela se produit

Les resolvers s'exécutent par champ, par élément. `Post.author` s'exécute séparément pour chaque post de la liste, et aucun d'eux n'a connaissance des autres, si bien que chacun fait son propre `findById`.

```js
// MAUVAIS : un appel DB par post -> N+1
const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.db.users.findById(post.authorId),
  },
};
```

## DataLoader : batch + cache

**DataLoader** diffère les appels individuels `.load(id)` effectués dans le même tick, puis transmet les clés collectées à une unique **batch function** qui les récupère toutes en une seule requête. Il **met aussi en cache** par clé au sein de la requête, si bien que les ids répétés sont gratuits.

```js
import DataLoader from "dataloader";

// crée UN loader par requête (à placer sur le context pour que le cache soit à la portée de la requête)
const userLoader = new DataLoader(async (ids) => {
  // ids arrive sous forme [1, 2, 3, ...] -> une seule requête groupée
  const users = await db.users.findByIds(ids);
  // DOIT renvoyer les valeurs dans le MÊME ORDRE que ids
  return ids.map((id) => users.find((u) => u.id === id));
});

const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.userLoader.load(post.authorId), // groupé
  },
};
// Désormais N resolvers author se réduisent à 1 requête : au total 2 requêtes, pas N+1.
```

Deux règles : créer les loaders **par requête** (pas globalement — vous laisseriez fuiter des données périmées entre utilisateurs), et la batch function doit renvoyer les résultats **dans l'ordre exact des clés**.

## Pourquoi c'est important

Le N+1 est le piège de performance le plus courant de GraphQL et une question d'entretien quasi garantie. Montrer que vous dégainez DataLoader — et savoir *pourquoi* il doit être à la portée de la requête et préserver l'ordre — témoigne d'une vraie expérience en production.

Pourquoi cela se produit

DataLoader : batch + cache

Pourquoi c'est important

Questions connexes