proofreading and spelling fixes

Author: sarahxsanders

website/pages/docs/n1-dataloader.mdx

@@ -2,9 +2,9 @@
 title: Solving the N+1 Problem with `DataLoader`
 ---
 
-When building a server with GraphQL.js, it's common to
-run into performance issues caused by the N+1 problem: a pattern that 
-leads to a large number of unnecessary database or service calls, 
+When building a server with GraphQL.js, it's common to encounter
+performance issues related to the N+1 problem: a pattern that 
+results in many unnecessary database or service calls, 
 especially in nested query structures.
 
 This guide explains what the N+1 problem is, why it's relevant in
@@ -15,7 +15,7 @@ GraphQL field resolution, and how to address it using
 
 The N+1 problem happens when your API fetches a list of items using one
 query, and then issues an additional query for each item in the list.
-In GraphQL, this ususally occurs in nested field resolvers.
+In GraphQL, this usually occurs in nested field resolvers.
 
 For example, in the following query:
 
@@ -34,8 +34,8 @@ For example, in the following query:
 If the `posts` field returns 10 items, and each `author` field fetches
 the author by ID with a separate database call, the server performs
 11 total queries: one to fetch the posts, and one for each post's author
-(10 total authors). This doesn't scale well as the number of parent items
-increases.
+(10 total authors). As the number of parent items increases, the number
+of database calls grows, which can degrade performance.
 
 Even if several posts share the same author, the server will still issue
 duplicate queries unless you implement deduplication or batching manually.
@@ -52,14 +52,16 @@ could be grouped.
 ## Solving the problem with `DataLoader`
 
 [`DataLoader`](https://github.com/graphql/dataloader) is a utility library designed
-to solver this problem. It batches multiple `.load(key)` calls into a single `batchLoadFn(keys)` 
+to solve this problem. It batches multiple `.load(key)` calls into a single `batchLoadFn(keys)` 
 call and caches results during the life of a request. This means you can reduce redundant data
 fetches and group related lookups into efficient operations.
 
-To use `DataLoader` in a `graphpql-js` server:
+To use `DataLoader` in a `graphql-js` server:
 
 1. Create `DataLoader` instances for each request.
-2. Attach the instance to the `contextValue` passed to GraphQL execution.
+2. Attach the instance to the `contextValue` passed to GraphQL execution. You can attach the 
+loader when calling [`graphql()`](https://graphql.org/graphql-js/graphql/#graphql) directly, or 
+when setting up a GraphQL HTTP server such as [express-graphql](https://github.com/graphql/express-graphql).
 3. Use `.load(id)` in resolvers to fetch data through the loader.
 
 ### Example: Batching author lookups
@@ -125,7 +127,7 @@ function createContext() {
 
 With this setup, all `.load(authorId)` calls are automatically collected and batched
 into a single call to `getUsersByIds`. `DataLoader` also caches results for the duration
-of the request, so repeated `.loads(id)` calls for the same ID don't trigger
+of the request, so repeated `.load(id)` calls for the same ID don't trigger
 additional fetches.
 
 ## Best practices
@@ -136,10 +138,11 @@ correctly and avoids leaking data between users.
 `DataLoader` contract. If a key is not found, return `null` or throw depending on
 your policy.
 - Keep batch functions focused. Each loader should handle a specific data access pattern.
-- Use `.loadMany()` sparingly. While it's useful in some cases, you usually don't need it
-in field resolvers. `.load()` is typically enough, and batching happens automatically.
+- Use `.loadMany()` sparingly. While it's useful when you already have a list of IDs, it's
+typically not needed in field resolvers, since `.load()` already batches individual calls
+made within the same execution cycle.
 
 ## Additional resources
 
 - [`DataLoader` GitHub repository](https://github.com/graphql/dataloader): Includes full API docs and usage examples
-- [GraphQL field resovlers](https://graphql.org/graphql-js/resolvers/): Background on how field resolution works.
+- [GraphQL field resolvers](https://graphql.org/graphql-js/resolvers/): Background on how field resolution works.