Parent (root) argument in GraphQL - Step-by-Step Execution

Concept Flow - Parent (root) argument

GraphQL Query Received

↓

Resolver Called

↓

Parent (root) Argument Passed

↓

Resolver Uses Parent to Access Data

↓

Return Data to Client

When a GraphQL query runs, each resolver gets a 'parent' argument that holds the result from the previous resolver, letting it access related data step-by-step.

Execution Sample

GraphQL

type Query {
  user(id: ID!): User
}

const resolver = {
  Query: {
    user: (parent, args) => {
      return getUserById(args.id);
    }
  }
};

This resolver gets called with a parent (root) argument and uses args to fetch a user by ID.

Execution Table

Step	Parent Argument	Args	Action	Result
1	{}	{id: "1"}	Call Query.user resolver	Calls getUserById("1")
2	{}	{id: "1"}	getUserById returns user object	{"id": "1", "name": "Alice"}
3	{"id": "1", "name": "Alice"}	{}	Pass user as parent to nested resolvers	User object available for child resolvers
4	User object	{}	Child resolver accesses parent to get user data	"Alice"
5	User object	{}	Return final data to client	{"user": {"id": "1", "name": "Alice"}}

💡 All resolvers finished, data returned to client

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
parent	{}	{}	{}	{"id": "1", "name": "Alice"}	{"id": "1", "name": "Alice"}
args	{}	{id: "1"}	{id: "1"}	{}	{}
result	undefined	undefined	{"id": "1", "name": "Alice"}	User object	{"user": {"id": "1", "name": "Alice"}}

Key Moments - 2 Insights

Why is the parent argument empty at the root resolver?

At the root level, the parent argument is an empty object because there is no previous resolver to pass data from, as shown in execution_table step 1.

How does the parent argument help nested resolvers?

Nested resolvers receive the parent argument containing data returned by their parent resolver, allowing them to access related fields, as seen in step 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the parent argument value at step 3?

A {"id": "1", "name": "Alice"}

B {}

C null

D {"id": "2", "name": "Bob"}

💡 Hint

Check the 'Parent Argument' column at step 3 in the execution_table.

At which step does the resolver get the user ID from args?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at the 'Args' and 'Action' columns in execution_table step 1.

If the parent argument was not passed to child resolvers, what would happen?

A Child resolvers would get default data automatically

B The query would fail immediately

C Child resolvers would have no access to parent data

D Parent argument is irrelevant for child resolvers

💡 Hint

Refer to key_moments about how nested resolvers use the parent argument.

Concept Snapshot

GraphQL resolvers receive a 'parent' argument holding data from the previous resolver.
At the root query, parent is empty ({}).
Child resolvers use parent to access related data.
This chaining allows nested data fetching step-by-step.
Always check parent to understand resolver context.

Full Transcript

When a GraphQL query runs, each resolver function is called with a 'parent' argument. This argument contains the result returned by the previous resolver in the chain. At the root query level, the parent argument is an empty object because there is no previous resolver. The resolver uses the arguments passed in the query to fetch data, for example, fetching a user by ID. Once the user data is returned, it becomes the parent argument for any nested resolvers. These nested resolvers can then access the parent data to resolve deeper fields. This flow allows GraphQL to fetch nested data step-by-step, passing context through the parent argument. Understanding the parent argument helps you see how data flows through resolvers and how nested queries get their data.