Nested resolver execution in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of nested resolvers in this GraphQL query?

Given the following GraphQL schema and resolvers, what will be the output of the query?

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

type User {
  id: ID!
  name: String!
  posts: [Post!]!
}

type Post {
  id: ID!
  title: String!
  comments: [Comment!]!
}

type Comment {
  id: ID!
  content: String!
}

Query:
{
  user(id: "1") {
    name
    posts {
      title
      comments {
        content
      }
    }
  }
}

Resolvers return these data objects:

user: { id: "1", name: "Alice", posts: [{ id: "101", title: "Hello World", comments: [{ id: "1001", content: "Nice post!" }] }] }

A {"data":{"user":{"name":"Alice","posts":[{"title":"Hello World","comments":[{"content":"Nice post!"}]}]}}}

B {"data":{"user":{"name":"Alice","posts":[{"title":"Hello World","comments":[]}]}}}

C {"data":{"user":{"name":"Alice","posts":[]}}}

D {"data":{"user":null}}

💡 Hint

Think about how nested resolvers return data objects and how GraphQL assembles the response.

The nested resolvers for posts and comments return the full data objects as specified. The query asks for name, posts.title, and comments.content. The output JSON reflects this nested structure with all requested fields.

🧠 Conceptual

intermediate

How does GraphQL execute nested resolvers?

When a GraphQL query requests nested fields, how does the execution of resolvers proceed?

A GraphQL executes all resolvers in parallel regardless of nesting order.

B GraphQL executes nested resolvers before parent resolvers.

C GraphQL executes only the top-level resolvers and ignores nested resolvers.

D GraphQL executes parent resolvers first, then executes child resolvers for nested fields sequentially.

💡 Hint

Think about how data dependencies flow from parent to child in nested queries.

GraphQL first resolves the parent field to get its data, then uses that data to resolve nested fields. This ensures nested resolvers have the context they need.

📝 Syntax

advanced

Identify the syntax error in this nested resolver function

Consider this JavaScript resolver function for a nested field in GraphQL:

const resolvers = {
  User: {
    posts(parent, args, context) {
      return context.db.posts.filter(post => post.userId === parent.id)
    },
    comments(parent, args, context) {
      return context.db.comments.filter(comment => comment.postId === parent.id)
    }
  }
}

What is the syntax error here?

A Missing comma between 'posts' and 'comments' resolver functions.

B Incorrect use of 'parent' parameter in 'comments' resolver.

C Missing return statement in 'posts' resolver.

D Using 'filter' method on undefined 'context.db.posts'.

💡 Hint

Check the object literal syntax inside the resolver map.

In JavaScript object literals, properties must be separated by commas. Here, the 'posts' and 'comments' resolver functions lack a comma between them, causing a syntax error.

🔧 Debug

advanced

Why does this nested resolver return empty arrays?

Given this resolver snippet:

const resolvers = {
  User: {
    posts(parent, args, context) {
      return context.db.posts.filter(post => post.userId === parent.id)
    }
  },
  Post: {
    comments(parent, args, context) {
      return context.db.comments.filter(comment => comment.postId === parent.id)
    }
  }
}

And the query:

{ user(id: "1") { posts { title comments { content } } } }

The response shows posts with titles but empty comments arrays. What is the most likely cause?

A The 'comments' resolver uses 'parent.id' but should use 'parent.postId'.

B The 'posts' resolver returns empty array, so no comments are fetched.

C The 'comments' resolver is not nested under 'Post' type in the schema.

D The 'comments' resolver is missing a return statement.

💡 Hint

Check if the resolver matches the schema type it belongs to.

If the 'comments' resolver is not correctly assigned to the 'Post' type in the schema, GraphQL will not call it for nested 'comments' fields, resulting in empty arrays.

❓ optimization

expert

How to optimize nested resolver execution to reduce database calls?

In a GraphQL API, nested resolvers for 'posts' and 'comments' cause many database calls, slowing response time. Which approach best optimizes this?

A Use multiple separate database connections for each nested resolver.

B Use DataLoader to batch and cache database requests for nested fields.

C Remove nested resolvers and fetch all data in the root resolver only.

D Cache the entire GraphQL response on the client side.

💡 Hint

Think about batching and caching repeated database queries during nested resolution.

DataLoader batches multiple requests for the same data into a single database call and caches results, reducing redundant queries in nested resolvers.

Practice

1. What is the main purpose of nested resolver execution in GraphQL?

easy

A. To convert GraphQL queries into SQL statements

B. To execute multiple queries in parallel without relation

C. To cache all data before sending a response

D. To fetch related data step-by-step using parent data

Solution

1. Step 1: Understand nested resolver role

   Nested resolvers use parent data to fetch related child data step-by-step.

2. Step 2: Compare other options

   Options B, C, and D describe unrelated or incorrect behaviors for nested resolvers.

3. Final Answer:

   To fetch related data step-by-step using parent data -> Option D

4. Quick Check:

   Nested resolver execution = step-by-step data fetch [OK]

Hint: Nested resolvers use parent info to get related data [OK]

Common Mistakes:

• Thinking nested resolvers run unrelated queries
• Confusing caching with resolver execution
• Assuming nested resolvers convert queries to SQL

2. Which of the following is the correct syntax for a nested resolver function in GraphQL?

easy

A. resolver(parent.id, fetchChildData)

B. fetchChildData(parent.id) => parent

C. parent => fetchChildData(parent.id)

D. child => parent.fetchData()

Solution

1. Step 1: Identify correct resolver signature

   Nested resolvers receive the parent object and use its fields to fetch related data, e.g., parent => fetchChildData(parent.id).

2. Step 2: Eliminate incorrect syntax

   Options B, C, and D do not follow the standard resolver function pattern.

3. Final Answer:

   parent => fetchChildData(parent.id) -> Option C

4. Quick Check:

   Nested resolver syntax = parent => fetchChildData(parent.id) [OK]

Hint: Nested resolver gets parent, then fetches child data [OK]

Common Mistakes:

• Reversing function parameters
• Using child as input instead of parent
• Incorrect arrow function placement

3. Given this GraphQL resolver snippet:

const resolvers = {
  User: {
    posts: (parent) => {
      return posts.filter(post => post.userId === parent.id);
    }
  }
};

What will User.posts return when called with parent = { id: 2 } if posts = [{id:1,userId:2},{id:2,userId:3},{id:3,userId:2}]?

medium

A. Error: posts is undefined

B. [{id:1,userId:2},{id:3,userId:2}]

C. []

D. [{id:2,userId:3}]

Solution

1. Step 1: Filter posts by parent.id

   The resolver filters posts where post.userId equals parent.id (2), so posts with userId 2 are selected.

2. Step 2: Identify matching posts

   Posts with id 1 and 3 have userId 2, so they are returned.

3. Final Answer:

   [{id:1,userId:2},{id:3,userId:2}] -> Option B

4. Quick Check:

   Filter posts by userId=2 = matching posts [OK]

Hint: Filter posts where userId matches parent.id [OK]

Common Mistakes:

• Returning posts with wrong userId
• Confusing parent.id with post.id
• Assuming empty result without checking data

4. Consider this nested resolver code:

const resolvers = {
  Author: {
    books: (parent) => {
      return books.filter(book => book.authorId = parent.id);
    }
  }
};

What is the error in this resolver?

medium

A. Using assignment '=' instead of comparison '===' in filter

B. Missing return statement in resolver

C. Incorrect resolver name 'books' instead of 'bookList'

D. Parent argument is not passed to resolver

Solution

1. Step 1: Identify filter condition mistake

   The filter uses '=' which assigns value instead of '===' which compares values.

2. Step 2: Understand impact of '=' in filter

   Using '=' causes all books to be included or unexpected behavior, not filtering correctly.

3. Final Answer:

   Using assignment '=' instead of comparison '===' in filter -> Option A

4. Quick Check:

   Filter condition must use '===' not '=' [OK]

Hint: Use '===' for comparison inside filter functions [OK]

Common Mistakes:

• Confusing '=' with '===' in conditions
• Forgetting to return filtered array
• Assuming resolver name must match data variable

5. You have a GraphQL schema with Author and nested books resolver. How would you optimize nested resolver execution to avoid fetching all books for each author individually?

hard

A. Batch book fetching using DataLoader to group requests by authorId

B. Fetch all books once and filter in each resolver call

C. Remove nested resolver and fetch books separately in client

D. Use multiple nested resolvers for each book field

Solution

1. Step 1: Understand nested resolver inefficiency

   Fetching books individually per author causes many database calls, slowing performance.

2. Step 2: Apply batching with DataLoader

   DataLoader batches requests by authorId, fetching all needed books in one query efficiently.

3. Final Answer:

   Batch book fetching using DataLoader to group requests by authorId -> Option A

4. Quick Check:

   Batching nested fetches = DataLoader usage [OK]

Hint: Use DataLoader to batch nested resolver database calls [OK]

Common Mistakes:

• Fetching all books every time wastes memory
• Removing nested resolver loses data relation
• Using multiple nested resolvers increases calls