All 15 GraphQL questions
More in GraphQL
What is the purpose of GraphQL fragments, and how do they help avoid duplicating field selections across multiple queries? How would you handle file uploads in a GraphQL API, given GraphQL's standard JSON-based transport doesn't naturally support binary file data? What is the purpose of GraphQL's non-null (!) type modifier, and what happens if a resolver for a non-null field returns null unexpectedly? What is the difference between a GraphQL scalar type and an object type, and how would you define a custom scalar (like DateTime) in a Node.js GraphQL server? How would you implement authentication and authorization in a GraphQL API in Node.js, given there's typically only a single HTTP endpoint? How would you implement query complexity analysis or depth limiting in a GraphQL API to prevent a maliciously deep or expensive query from overwhelming the server? How would you implement GraphQL schema stitching or federation to compose a single unified GraphQL API from multiple underlying microservices? How would you implement caching for a GraphQL API, given that unlike REST, a single endpoint serves widely varying query shapes that don't map cleanly to standard HTTP caching? How would you write automated tests for GraphQL resolvers in Node.js, testing them independently of the full HTTP/schema execution layer?
Advertisement
Node.js › GraphQL

What is the N+1 query problem in GraphQL specifically, and how does DataLoader solve it?

Advanced

Answer

Because each field in a GraphQL query has its own independent resolver, a query returning a list of parent objects (like 100 posts) followed by each post's author field naturally triggers a separate resolver call (and potentially a separate database query) for each post's author individually -- resulting in 101 total queries. DataLoader solves this by batching and deduplicating requests made within a single tick of the event loop, collecting all the individual author IDs requested during that tick and issuing a single batched query for all of them at once, then distributing the results back to each individual resolver call.
const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
  const users = await db.users.find({ id: { $in: userIds } }); // single batched query
  return userIds.map(id => users.find(u => u.id === id));
});

// Each individual resolver call transparently benefits from batching
const resolvers = {
  Post: { author: (post) => userLoader.load(post.authorId) },
};
Real-world example A social media API's post-listing query, which previously issued 101 separate database queries to resolve 100 posts' individual author fields, drops to just 2 total queries (one for the posts, one batched query for all needed authors) after introducing DataLoader for the author field's resolver.

Common follow-ups: How does DataLoader's batching mechanism actually work using microtask timing to collect requests within a single tick?;What's the difference between DataLoader's batching and caching behaviors, and why does DataLoader typically need to be instantiated fresh per request?

Databases & ORMs (MongoDB/Mongoose SQL/Sequelize);Performance Optimization & Profiling
All 15 GraphQL questions