Che cos'è il problema N+1 in GraphQL e come lo risolve DataLoader?

Question

IT Interview Practice · Accepted Answer

Il **problema N+1** si verifica quando il resolver di un campo viene eseguito una volta per ogni elemento parent e ogni esecuzione emette la propria query al database. Recuperare una lista di N post e poi l'autore di ciascun post genera **1 query per i post + N query per gli autori** — N+1 round trip che sotto carico distruggono le prestazioni.

## Perché succede

I resolver vengono eseguiti per campo, per elemento. `Post.author` viene eseguito separatamente per ogni post della lista, e nessuno di essi sa degli altri, quindi ciascuno effettua il proprio `findById`.

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

## DataLoader: batch + cache

**DataLoader** rimanda le singole chiamate `.load(id)` effettuate nello stesso tick, poi passa le chiavi raccolte a un'unica **funzione di batch** che le recupera tutte con una sola query. Inoltre esegue il **caching** per chiave all'interno della richiesta, quindi gli id ripetuti sono gratuiti.

```js
import DataLoader from "dataloader";

// create ONE loader per request (put it on context so caching is request-scoped)
const userLoader = new DataLoader(async (ids) => {
  // ids arrives as [1, 2, 3, ...] -> a single batched query
  const users = await db.users.findByIds(ids);
  // MUST return values in the SAME ORDER as ids
  return ids.map((id) => users.find((u) => u.id === id));
});

const resolvers = {
  Post: {
    author: (post, _a, ctx) => ctx.userLoader.load(post.authorId), // batched
  },
};
// Now N author resolvers collapse into 1 query: total 2 queries, not N+1.
```

Due regole: crea i loader **per richiesta** (non globalmente — trapeleresti dati obsoleti tra un utente e l'altro), e la funzione di batch deve restituire i risultati **nell'esatto ordine delle chiavi**.

## Perché è importante

N+1 è la trappola di prestazioni più comune in assoluto in GraphQL e una domanda da colloquio quasi garantita. Dimostrare che ricorri a DataLoader — e che sai *perché* deve avere ambito di richiesta e preservare l'ordine — segnala vera esperienza di produzione.

Perché succede

DataLoader: batch + cache

Perché è importante

Domande correlate