Resolver chains in GraphQL - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a resolver that returns the user's name.

GraphQL

const resolvers = {
  Query: {
    user: (parent, args, context, info) => [1]
  }
};

Drag options to blanks, or click blank then click option'

Aparent.name

Bcontext.db.getUserName()

Cargs.id

Dinfo.fieldName

Attempts:

3 left

💡 Hint

Common Mistakes

Using args.id instead of parent.name

Trying to access context without it being passed

The resolver function accesses the parent object to get the user's name.

2fill in blank

medium

Complete the resolver chain to fetch the user's posts from the database.

GraphQL

const resolvers = {
  User: {
    posts: (parent, args, context) => [1]
  }
};

Drag options to blanks, or click blank then click option'

Aparent.posts

Bcontext.db.getPostsByUserId(parent.id)

Cargs.posts

Dcontext.posts

Attempts:

3 left

💡 Hint

Common Mistakes

Using parent.posts which may not be populated

Using args.posts which is incorrect

The resolver uses the context to access the database and fetch posts by the user's ID.

3fill in blank

hard

Fix the error in the resolver chain to correctly resolve the user's profile picture URL.

GraphQL

const resolvers = {
  User: {
    profilePicture: (parent, args, context) => {
      return context.storage.getUrl([1]);
    }
  }
};

Drag options to blanks, or click blank then click option'

Acontext.userId

Bargs.profilePicId

Cparent.id

Dparent.profilePicId

Attempts:

3 left

💡 Hint

Common Mistakes

Using args.profilePicId which is not passed

Using parent.id which is the user ID, not picture ID

The resolver should use the profilePicId from the parent object to get the URL.

4fill in blank

hard

Fill both blanks to create a resolver chain that fetches comments for a post and filters by author ID.

GraphQL

const resolvers = {
  Post: {
    comments: (parent, args, context) => {
      return context.db.getCommentsByPostId(parent.[1]).filter(comment => comment.[2] === args.authorId);
    }
  }
};

Drag options to blanks, or click blank then click option'

Aid

BpostId

CauthorId

DuserId

Attempts:

3 left

💡 Hint

Common Mistakes

Using parent.postId which does not exist

Filtering by comment.userId instead of authorId

The post's ID is parent.id, and comments have an authorId to filter by.

5fill in blank

hard

Fill all three blanks to create a resolver chain that fetches a user's friends and maps their names.

GraphQL

const resolvers = {
  User: {
    friendsNames: async (parent, args, context) => {
      const friends = await context.db.getFriendsByUserId(parent.[1]);
      return friends.map(friend => friend.[2]).filter(name => name [3] '');
    }
  }
};

Drag options to blanks, or click blank then click option'

Aid

BuserId

Cname

D!==

Attempts:

3 left

💡 Hint

Common Mistakes

Using userId instead of id

Mapping friend.userId instead of friend.name

Using == instead of !== for filtering

The resolver uses parent.id to get friends, maps their name, and filters out empty names using !==.

Practice

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

easy

A. To speed up database indexing

B. To create new database tables automatically

C. To fetch data step-by-step using results from previous resolvers

D. To encrypt data before sending it to clients

Solution

1. Step 1: Understand resolver chains concept

   Resolver chains allow each resolver to use data from the previous resolver's result, enabling step-by-step data fetching.

2. Step 2: Compare options with concept

   Only To fetch data step-by-step using results from previous resolvers describes this stepwise data fetching using parent results, which matches the purpose of resolver chains.

3. Final Answer:

   To fetch data step-by-step using results from previous resolvers -> Option C

4. Quick Check:

   Resolver chains = step-by-step data fetching [OK]

Hint: Resolver chains pass data stepwise between resolvers [OK]

Common Mistakes:

• Confusing resolver chains with database indexing
• Thinking resolver chains create tables
• Assuming resolver chains encrypt data

2. Which of the following is the correct way to access the parent resolver's result in a GraphQL resolver function?

easy

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

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

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

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

Solution

1. Step 1: Recall resolver function signature

   In GraphQL, the first argument to a resolver is the parent object, followed by args and context.

2. Step 2: Match signature with options

   Only function resolver(parent, args, context) { ... } correctly places parent as the first argument, allowing access to previous resolver's result.

3. Final Answer:

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

4. Quick Check:

   Parent is first argument in resolver [OK]

Hint: Parent is always the first argument in resolver functions [OK]

Common Mistakes:

• Swapping order of arguments
• Omitting the parent argument
• Confusing context with parent

3. Given the following resolver chain, what will be the final output?

const resolvers = {
  Query: {
    user: () => ({ id: 1, name: 'Alice' })
  },
  User: {
    posts: (parent) => [
      { id: 101, title: 'Post 1', authorId: parent.id },
      { id: 102, title: 'Post 2', authorId: parent.id }
    ]
  }
};

// Query: { user { name posts { title } } }

medium

A. { user: { name: 'Alice', posts: [] } }

B. { user: { name: 'Alice', posts: [{ title: 'Post 1' }, { title: 'Post 2' }] } }

C. { user: { name: 'Alice', posts: [{ title: 'Post 1' }, { title: 'Post 2' }, { title: 'Post 3' }] } }

D. Error: Cannot read property 'id' of undefined

Solution

1. Step 1: Analyze user resolver output

   The user resolver returns an object with id 1 and name 'Alice'.

2. Step 2: Analyze posts resolver using parent

   The posts resolver receives parent with id 1, so it returns two posts with authorId 1 and titles 'Post 1' and 'Post 2'.

3. Final Answer:

   { user: { name: 'Alice', posts: [{ title: 'Post 1' }, { title: 'Post 2' }] } } -> Option B

4. Quick Check:

   Posts use parent.id = 1, two posts returned [OK]

Hint: Parent contains previous resolver's data for next resolver [OK]

Common Mistakes:

• Assuming posts resolver returns three posts
• Expecting empty posts array
• Confusing parent argument as undefined

4. Identify the error in this resolver chain code snippet:

const resolvers = {
  Query: {
    book: () => ({ id: 5, title: 'GraphQL Guide' })
  },
  Book: {
    author: (args) => {
      return { id: 2, name: 'John Doe' };
    }
  }
};

medium

A. The author resolver is missing the parent argument

B. The book resolver should return a list, not an object

C. The author resolver should not return an object

D. The Query resolver should have three arguments

Solution

1. Step 1: Check author resolver signature

   The author resolver should receive the parent object as the first argument to access book data.

2. Step 2: Identify missing parent argument

   Here, author resolver only has args, so it cannot access parent data, breaking the resolver chain.

3. Final Answer:

   The author resolver is missing the parent argument -> Option A

4. Quick Check:

   Resolvers need parent as first argument [OK]

Hint: Always include parent as first argument in chained resolvers [OK]

Common Mistakes:

• Ignoring parent argument in nested resolvers
• Thinking book resolver must return a list
• Assuming author resolver cannot return objects

5. You want to fetch a list of orders with their customer names using resolver chains. The orders resolver returns an array of orders with customerId. How should you implement the customer resolver to correctly use resolver chains?

hard

A. Use the parent argument to get customerId and fetch customer data from database

B. Ignore the parent argument and fetch all customers in the customer resolver

C. Pass customerId as an argument to the orders resolver

D. Return a static customer object without using parent data

Solution

1. Step 1: Understand data flow in resolver chains

   The orders resolver returns orders with customerId; the customer resolver uses parent to access customerId.

2. Step 2: Use parent argument in customer resolver

   The customer resolver should use parent.customerId to fetch the correct customer data from the database.

3. Final Answer:

   Use the parent argument to get customerId and fetch customer data from database -> Option A

4. Quick Check:

   Parent passes customerId to customer resolver [OK]

Hint: Use parent.customerId in customer resolver to fetch data [OK]

Common Mistakes:

• Fetching all customers instead of one
• Ignoring parent and missing customerId
• Returning static data ignoring dynamic parent info