O que é o problema N+1 no GraphQL e como o DataLoader o resolve?

Question

IT Interview Practice · Accepted Answer

O **problema N+1** acontece quando um resolver de campo roda uma vez por item pai e cada execução dispara sua própria consulta ao banco de dados. Buscar uma lista de N posts e depois o autor de cada post dispara **1 consulta para os posts + N consultas para os autores** — N+1 idas e voltas que arrasam o desempenho sob carga.

## Por que acontece

Os resolvers rodam por campo, por item. `Post.author` executa separadamente para cada post da lista, e nenhum deles sabe dos outros, então cada um faz seu próprio `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

O **DataLoader** adia as chamadas individuais `.load(id)` feitas no mesmo tick e depois entrega as chaves coletadas a uma única **batch function** que busca todas em uma só consulta. Ele também faz **cache** por chave dentro da requisição, então ids repetidos saem de graça.

```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.
```

Duas regras: crie os loaders **por requisição** (não globalmente — você vazaria dados obsoletos entre usuários), e a batch function deve retornar os resultados **na ordem exata das chaves**.

## Por que isso importa

N+1 é a armadilha de desempenho mais comum do GraphQL e uma pergunta de entrevista quase garantida. Mostrar que você recorre ao DataLoader — e sabe *por que* ele deve ser request-scoped e preservar a ordem — sinaliza experiência real de produção.

Por que acontece

DataLoader: batch + cache

Por que isso importa

Perguntas relacionadas