Wat is het N+1-probleem in GraphQL en hoe lost DataLoader het op?

Question

IT Interview Practice · Accepted Answer

Het **N+1-probleem** treedt op wanneer een veld-resolver één keer per parent-item draait en elke run zijn eigen database-query afvuurt. Een lijst van N posts ophalen en vervolgens de author van elke post levert **1 query voor de posts + N queries voor de authors** op — N+1 round trips die de performance onder belasting onderuithalen.

## Waarom het gebeurt

Resolvers draaien per veld, per item. `Post.author` wordt apart uitgevoerd voor elke post in de lijst, en geen van hen weet van de anderen af, dus elk doet zijn eigen `findById`.

```js
// SLECHT: één DB-call per post -> N+1
const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.db.users.findById(post.authorId),
  },
};
```

## DataLoader: batchen + cachen

**DataLoader** stelt individuele `.load(id)`-calls die in dezelfde tick worden gedaan uit, en geeft de verzamelde keys vervolgens door aan één **batch-functie** die ze allemaal in één query ophaalt. Het **cachet** ook per key binnen het request, zodat herhaalde ids gratis zijn.

```js
import DataLoader from "dataloader";

// maak ÉÉN loader per request (zet hem op context zodat de cache request-scoped is)
const userLoader = new DataLoader(async (ids) => {
  // ids arriveert als [1, 2, 3, ...] -> één gebatchte query
  const users = await db.users.findByIds(ids);
  // MOET waarden teruggeven in DEZELFDE VOLGORDE als ids
  return ids.map((id) => users.find((u) => u.id === id));
});

const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.userLoader.load(post.authorId), // gebatcht
  },
};
// Nu klappen N author-resolvers samen tot 1 query: in totaal 2 queries, niet N+1.
```

Twee regels: maak loaders **per request** (niet globaal — dan lek je verouderde data tussen users), en de batch-functie moet resultaten **in exact de key-volgorde** teruggeven.

## Waarom het belangrijk is

N+1 is de meest voorkomende GraphQL-performanceval en een vrijwel gegarandeerde interviewvraag. Laten zien dat je naar DataLoader grijpt — en weet *waarom* het request-scoped en volgorde-behoudend moet zijn — signaleert echte productie-ervaring.

Waarom het gebeurt

DataLoader: batchen + cachen

Waarom het belangrijk is

Gerelateerde vragen