Resolver organization in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of organizing resolvers in GraphQL?

Why do developers organize resolvers in a structured way when building GraphQL APIs?

A To improve code readability and maintainability by grouping related resolvers together

B To increase the size of the GraphQL schema automatically

C To prevent clients from querying the API

D To make the API slower by adding more layers of abstraction

💡 Hint

Think about how organizing code helps when the project grows larger.

Organizing resolvers helps developers find and update code easily, making the API easier to maintain and extend.

❓ query_result

intermediate

What is the output of this resolver organization pattern?

Given the following resolver structure, what will be the result of querying user.name?

GraphQL

const resolvers = {
  Query: {
    user: () => ({ id: 1, name: 'Alice' })
  },
  User: {
    name: (parent) => parent.name.toUpperCase()
  }
};

A "Alice"

B "ALICE"

C null

D Error: name resolver missing

💡 Hint

Look at how the User.name resolver modifies the name.

The User.name resolver takes the original name and converts it to uppercase before returning it.

📝 Syntax

advanced

Identify the syntax error in this resolver organization code

Which option contains the syntax error in organizing resolvers?

GraphQL

const resolvers = {
  Query: {
    user: () => ({ id: 1, name: 'Bob' })
  },
  User: {
    name: (parent) => parent.name.toLowerCase()
  }
};

A const resolvers = { Query: { user: () => ({ id: 1, name: 'Bob' }) }, User: { name: (parent) => parent.name.toLowerCase() } };

B const resolvers = { Query: { user: () => ({ id: 1, name: 'Bob' }) }, User: { name: parent => parent.name.toLowerCase() } };

C const resolvers = { Query: { user: () => ({ id: 1, name: 'Bob' }) }, User: { name: (parent) => parent.name.toLowerCase() }

D ;} } )(esaCrewoLot.eman.tnerap >= )tnerap( :eman { :resU ,} )} 'boB' :eman ,1 :di {( >= )( :resu { :yreuQ { = srevloser tsnoc

💡 Hint

Check for missing brackets or punctuation.

Option C is missing the closing brace for the resolvers object, causing a syntax error.

❓ optimization

advanced

Which resolver organization improves performance by avoiding redundant data fetching?

Consider these resolver organizations. Which one best avoids fetching the same data multiple times?

A Resolvers that cache data on the client side only

B Separate resolvers for each field that each fetch data independently from the database

C Resolvers that fetch data only when the client requests the entire schema

D A single resolver for the parent type that fetches all needed data once and passes it down

💡 Hint

Think about how to reduce repeated database calls.

Fetching all data once in the parent resolver and passing it down avoids multiple database calls, improving performance.

🔧 Debug

expert

Why does this resolver organization cause a 'Cannot read property' error?

Given this resolver code, why does querying post.author.name cause an error?

GraphQL

const resolvers = {
  Query: {
    post: () => ({ id: 1, authorId: 2 })
  },
  Post: {
    author: (parent) => getUserById(parent.authorId)
  },
  User: {
    name: (parent) => parent.name.toUpperCase()
  }
};

function getUserById(id) {
  return { id, /* missing name property */ };
}

A Because getUserById returns an object without a 'name' property, so 'parent.name' is undefined

B Because the 'author' resolver is missing a return statement

C Because the 'name' resolver should not use 'parent' as argument

D Because the 'post' resolver returns an object without 'author' property

💡 Hint

Check what data the author resolver returns and what the name resolver expects.

The getUserById function returns an object missing the name property. When the name resolver tries to access parent.name, it is undefined, causing an error.