Context argument in GraphQL - Step-by-Step Execution

Concept Flow - Context argument

Client sends GraphQL query

↓

GraphQL Server receives query

↓

Server creates Context object

↓

Resolver functions called with Context

↓

Resolvers use Context for shared data

↓

Resolvers return data

↓

Server sends response to Client

The context argument is created once per request and passed to all resolvers, allowing them to share data like authentication info or database connections.

Execution Sample

GraphQL

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: ({ req }) => ({ user: req.user })
});

This code creates a GraphQL server that passes the user info from the request into the context for all resolvers.

Execution Table

Step	Action	Context Created	Resolver Called	Context Used	Result
1	Client sends query	No	No	No	Waiting for server
2	Server receives query	No	No	No	Preparing to create context
3	Create context from request	Yes: { user: req.user }	No	No	Context ready
4	Call resolver A	Yes	Yes	Access context.user	Resolver A returns data with user info
5	Call resolver B	Yes	Yes	Access context.user	Resolver B returns data with user info
6	Send response to client	Yes	No	Yes	Client receives data

💡 All resolvers called with the same context object; response sent after all resolvers finish.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
context	undefined	{ user: req.user }	{ user: req.user }	{ user: req.user }	{ user: req.user }
resolverResultA	undefined	undefined	data with user info	data with user info	data with user info
resolverResultB	undefined	undefined	undefined	data with user info	data with user info

Key Moments - 2 Insights

Why is the context created only once per request and not per resolver?

Because the context is shared across all resolvers for the same request to provide consistent data like authentication info, as shown in execution_table steps 3 to 5.

How do resolvers access the context argument?

Resolvers receive the context as a third argument and can access its properties directly, as seen in execution_table steps 4 and 5 where context.user is used.

Visual Quiz - 3 Questions

Look at the execution_table, at which step is the context object created?

A Step 3

B Step 4

C Step 2

D Step 5

💡 Hint

Check the 'Context Created' column in execution_table rows.

According to variable_tracker, what is the value of 'context' after Step 5?

A undefined

B { user: req.user }

C null

D {}

💡 Hint

Look at the 'context' row and the 'After Step 5' column in variable_tracker.

If the context was created separately for each resolver, how would the execution_table change?

A Context Created would be 'No' at all steps

B Context Created would be 'Yes' only at Step 3

C Context Created would be 'Yes' at Steps 4 and 5 separately

D Context Created would be 'Yes' only at Step 6

💡 Hint

Think about when context is created and used in execution_table steps 3, 4, and 5.

Concept Snapshot

Context argument in GraphQL:
- Created once per request
- Passed to all resolvers
- Holds shared data (e.g., user info)
- Accessed as third argument in resolvers
- Enables consistent data access across resolvers

Full Transcript

In GraphQL, the context argument is an object created once for each client request. It is passed to every resolver function during that request. This allows resolvers to share common data like authentication details or database connections. The server creates the context after receiving the query and before calling any resolvers. Each resolver can then access the context to get needed information. After all resolvers finish, the server sends the response back to the client. This flow ensures consistent and secure data handling across the entire query execution.

Practice

1. What is the main purpose of the context argument in GraphQL resolvers?

easy

A. To format the response data before sending it to the client

B. To define the GraphQL schema types

C. To specify the query operation type (query, mutation, subscription)

D. To share common data like authentication or database access across all resolvers during a request

Solution

1. Step 1: Understand the role of context in GraphQL

   The context argument is designed to hold data shared by all resolvers during a single request, such as authentication info or database connections.

2. Step 2: Compare with other options

   Defining schema types, specifying operation types, or formatting responses are handled elsewhere, not by context.

3. Final Answer:

   To share common data like authentication or database access across all resolvers during a request -> Option D

4. Quick Check:

   Context = Shared data for resolvers [OK]

Hint: Context holds shared info for all resolvers in a request [OK]

Common Mistakes:

• Confusing context with schema definition
• Thinking context formats responses
• Assuming context defines operation types

2. Which of the following is the correct way to access the context argument in a GraphQL resolver function?

easy

A. resolver(parent, args, context) { ... }

B. resolver(context, args, parent) { ... }

C. resolver(args, parent, context) { ... }

D. resolver(args, context) { ... }

Solution

1. Step 1: Recall resolver function signature

   GraphQL resolvers receive arguments in the order: parent, args, context.

2. Step 2: Match the correct order

   Only resolver(parent, args, context) { ... } matches this order correctly.

3. Final Answer:

   resolver(parent, args, context) { ... } -> Option A

4. Quick Check:

   Resolver args order = parent, args, context [OK]

Hint: Remember resolver args order: parent, args, context [OK]

Common Mistakes:

• Swapping context and args positions
• Omitting the parent argument
• Using only two arguments instead of three

3. Given this resolver code snippet:

const resolver = (parent, args, context) => {
  return context.db.getUserById(args.id);
};

What will resolver(null, {id: 5}, context) return if context.db.getUserById(5) returns { id: 5, name: 'Alice' }?

medium

A. null

B. { id: 5, name: 'Alice' }

C. undefined

D. Error: getUserById is not a function

Solution

1. Step 1: Understand the resolver call

   The resolver calls context.db.getUserById with args.id which is 5.

2. Step 2: Check the return value from context

   Given context.db.getUserById(5) returns { id: 5, name: 'Alice' }, the resolver returns this object.

3. Final Answer:

   { id: 5, name: 'Alice' } -> Option B

4. Quick Check:

   Resolver returns context.db.getUserById(args.id) result [OK]

Hint: Resolver returns what context function returns for given args [OK]

Common Mistakes:

• Assuming resolver returns null or undefined
• Confusing parent argument with context
• Expecting an error without checking context structure

4. Consider this resolver code:

const resolver = (parent, args, context) => {
  return context.getUser(args.id);
};

If running this code causes TypeError: context.getUser is not a function, what is the most likely cause?

medium

A. The context object does not have a getUser method

B. The args.id is undefined

C. The parent argument is missing

D. The resolver function is missing the args parameter

Solution

1. Step 1: Analyze the error message

   The error says getUser is not a function on context, meaning context.getUser is undefined or not callable.

2. Step 2: Check other options

   Undefined args.id or missing parent won't cause this specific error. Missing args parameter would cause a different error.

3. Final Answer:

   The context object does not have a getUser method -> Option A

4. Quick Check:

   TypeError means missing method on context [OK]

Hint: TypeError means method missing on context object [OK]

Common Mistakes:

• Blaming args.id for method not found error
• Assuming parent argument causes this error
• Ignoring that context must have the method

5. You want to add user authentication info to all resolvers using the context argument. Which approach correctly sets up the context for this purpose?

hard

A. Pass user info as an argument in every query instead of context

B. Define user info inside each resolver separately without using context

C. Create context once per request including user info, then pass it to all resolvers

D. Use global variables to store user info accessible by resolvers

Solution

1. Step 1: Understand context usage for shared data

   Context is designed to be created once per request and shared with all resolvers, perfect for authentication info.

2. Step 2: Evaluate other options

   Defining user info inside each resolver duplicates code; passing user info as query args is insecure and inconvenient; global variables are unsafe for concurrent requests.

3. Final Answer:

   Create context once per request including user info, then pass it to all resolvers -> Option C

4. Quick Check:

   Context = single shared object per request [OK]

Hint: Set context once per request with user info for all resolvers [OK]

Common Mistakes:

• Duplicating user info in every resolver
• Passing sensitive info as query arguments
• Using global variables causing data leaks