Nested resolver execution in GraphQL - Mini Project: Build & Apply

Nested Resolver Execution in GraphQL

📖 Scenario: You are building a simple GraphQL API for a bookstore. The API should return books along with their authors. Each book has a title and an author, and each author has a name and a list of books they wrote.

🎯 Goal: Create a GraphQL schema with nested resolvers so that when querying for books, you also get the author details, and when querying for authors, you get their books. This will demonstrate how nested resolver execution works in GraphQL.

📋 What You'll Learn

Create a Book type with fields title (String) and author (Author).

Create an Author type with fields name (String) and books (list of Book).

Create a root Query type with fields books and authors returning lists of Book and Author respectively.

Implement resolvers for books and authors queries.

Implement nested resolvers for author field in Book and books field in Author.

Use hardcoded data for books and authors to simulate a database.

💡 Why This Matters

🌍 Real World

GraphQL APIs often need to fetch related data in nested queries, such as fetching an author when querying a book. Understanding nested resolver execution helps build efficient and clear APIs.

💼 Career

Backend developers and API engineers use GraphQL nested resolvers to design flexible APIs that clients can query for exactly the data they need, improving performance and developer experience.

1

Define the GraphQL schema types

Create a GraphQL schema with Book and Author types. The Book type should have fields title (String) and author (Author). The Author type should have fields name (String) and books (list of Book).

GraphQL

type Book {
  title: String
  author: Author
}

type Author {
  name: String
  books: [Book]
}

# Define Book and Author types with the specified fields

Hint

Define Book and Author types with the exact fields and types as described.

2

Add the root Query type with books and authors fields

Add a root Query type with two fields: books returning a list of Book, and authors returning a list of Author.

GraphQL

type Book {
  title: String
  author: Author
}

type Author {
  name: String
  books: [Book]
}

type Query {
  books: [Book]
  authors: [Author]
}

# Add Query type with books and authors fields

Hint

Define the Query type with books and authors fields returning lists of the respective types.

3

Create hardcoded data and resolvers for books and authors

Create two arrays: books and authors with hardcoded data. Then create resolvers for the root Query fields books and authors that return these arrays.

GraphQL

const authors = [
  { id: 1, name: "Jane Austen" },
  { id: 2, name: "Mark Twain" }
];

const books = [
  { title: "Pride and Prejudice", authorId: 1 },
  { title: "Adventures of Huckleberry Finn", authorId: 2 }
];

const resolvers = {
  Query: {
    books: () => books,
    authors: () => authors
  }
};

# Create hardcoded data arrays and resolvers for Query fields

Hint

Create arrays named books and authors with the exact data shown. Then create a resolvers object with a Query field that returns these arrays.

4

Add nested resolvers for author in Book and books in Author

Add nested resolvers inside resolvers for the Book type's author field and the Author type's books field. The author resolver should find the author by matching authorId in the book. The books resolver should find all books with authorId matching the author's id.

GraphQL

const authors = [
  { id: 1, name: "Jane Austen" },
  { id: 2, name: "Mark Twain" }
];

const books = [
  { title: "Pride and Prejudice", authorId: 1 },
  { title: "Adventures of Huckleberry Finn", authorId: 2 }
];

const resolvers = {
  Query: {
    books: () => books,
    authors: () => authors
  },
  Book: {
    author: (book) => authors.find(author => author.id === book.authorId)
  },
  Author: {
    books: (author) => books.filter(book => book.authorId === author.id)
  }
};

# Add nested resolvers for Book.author and Author.books

Hint

Inside resolvers, add Book and Author objects with resolver functions for author and books fields respectively, using find and filter on the data arrays.

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