Resolver organization in GraphQL - Mini Project: Build & Apply

Organizing GraphQL Resolvers for a Bookstore

📖 Scenario: You are building a simple GraphQL API for a bookstore. The API needs to provide information about books and authors.To keep your code clean and easy to maintain, you want to organize your GraphQL resolvers properly.

🎯 Goal: Build a well-organized set of GraphQL resolvers separated by type (Query, Book, Author) to fetch book and author data.

📋 What You'll Learn

Create a books array with 3 books, each having id, title, and authorId

Create an authors array with 2 authors, each having id and name

Create a resolvers object with three keys: Query, Book, and Author

In Query, add a resolver books that returns the books array

In Book, add a resolver author that returns the author object matching the book's authorId

In Author, add a resolver books that returns all books written by that author

💡 Why This Matters

🌍 Real World

Organizing resolvers by type is a common practice in real GraphQL APIs to keep code modular and easy to understand.

💼 Career

Understanding resolver organization is essential for backend developers working with GraphQL to build scalable and maintainable APIs.

1

Create the initial data arrays

Create an array called books with these exact objects: { id: '1', title: '1984', authorId: 'a1' }, { id: '2', title: 'Animal Farm', authorId: 'a1' }, and { id: '3', title: 'Brave New World', authorId: 'a2' }. Also create an array called authors with these exact objects: { id: 'a1', name: 'George Orwell' } and { id: 'a2', name: 'Aldous Huxley' }.

GraphQL

# Your code here

Hint

Use const books = [...] and const authors = [...] to create the arrays with the exact objects.

2

Create the resolver object with Query type

Create a resolvers object. Inside it, add a Query object with a resolver function books that returns the books array.

GraphQL

const books = [
  { id: '1', title: '1984', authorId: 'a1' },
  { id: '2', title: 'Animal Farm', authorId: 'a1' },
  { id: '3', title: 'Brave New World', authorId: 'a2' }
];

const authors = [
  { id: 'a1', name: 'George Orwell' },
  { id: 'a2', name: 'Aldous Huxley' }
];

const resolvers = {
  Query: {
    // Your code here
  }
};

Hint

Inside resolvers, add Query: { books: () => books } to return the books array.

3

Add the Book type resolver for author

Inside the resolvers object, add a Book object. Add a resolver function author that takes book as an argument and returns the author object from authors whose id matches book.authorId.

GraphQL

const books = [
  { id: '1', title: '1984', authorId: 'a1' },
  { id: '2', title: 'Animal Farm', authorId: 'a1' },
  { id: '3', title: 'Brave New World', authorId: 'a2' }
];

const authors = [
  { id: 'a1', name: 'George Orwell' },
  { id: 'a2', name: 'Aldous Huxley' }
];

const resolvers = {
  Query: {
    books: () => books
  },
  Book: {
    // Your code here
  }
};

Hint

Use Book: { author: (book) => authors.find(author => author.id === book.authorId) } inside resolvers.

4

Add the Author type resolver for books

Inside the resolvers object, add an Author object. Add a resolver function books that takes author as an argument and returns an array of books from books whose authorId matches author.id.

GraphQL

const books = [
  { id: '1', title: '1984', authorId: 'a1' },
  { id: '2', title: 'Animal Farm', authorId: 'a1' },
  { id: '3', title: 'Brave New World', authorId: 'a2' }
];

const authors = [
  { id: 'a1', name: 'George Orwell' },
  { id: 'a2', name: 'Aldous Huxley' }
];

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

Hint

Use Author: { books: (author) => books.filter(book => book.authorId === author.id) } inside resolvers.

Practice

1. What is the main purpose of resolvers in a GraphQL server?

easy

A. To connect schema fields to the actual data sources

B. To define the GraphQL schema types and fields

C. To handle client-side state management

D. To style the GraphQL playground interface

Solution

1. Step 1: Understand the role of resolvers

   Resolvers are functions that fetch or compute the data for each field in the GraphQL schema.

2. Step 2: Identify what resolvers connect

   Resolvers connect the schema fields to the actual data sources like databases or APIs.

3. Final Answer:

   To connect schema fields to the actual data sources -> Option A

4. Quick Check:

   Resolvers = Connect schema to data [OK]

Hint: Resolvers link schema fields directly to data sources [OK]

Common Mistakes:

• Confusing resolvers with schema definitions
• Thinking resolvers handle UI or styling
• Assuming resolvers manage client state

2. Which of the following is the correct way to organize resolvers in a GraphQL server?

easy

A. Group resolvers by Query, Mutation, and type names

B. Put all resolvers in a single flat list without grouping

C. Write resolvers only inside the schema definition file

D. Use one resolver function for the entire schema

Solution

1. Step 1: Recognize common resolver organization

   Resolvers are typically grouped by operation types: Query, Mutation, and by object types for clarity.

2. Step 2: Evaluate the options

   Grouping by Query, Mutation, and types helps maintain and scale the server easily.

3. Final Answer:

   Group resolvers by Query, Mutation, and type names -> Option A

4. Quick Check:

   Organize resolvers by operation type [OK]

Hint: Group resolvers by Query, Mutation, and types for clarity [OK]

Common Mistakes:

• Putting all resolvers in one list without grouping
• Mixing resolver code inside schema files
• Using a single resolver for all fields

3. Given this resolver structure:

const resolvers = {
  Query: {
    user: () => ({ id: 1, name: "Alice" })
  },
  User: {
    fullName: (parent) => parent.name + " Smith"
  }
};

What will be the result of querying { user { fullName } }?

medium

A. Error: Resolver for fullName missing

B. { "user": { "fullName": "Smith" } }

C. { "user": { "fullName": null } }

D. { "user": { "fullName": "Alice Smith" } }

Solution

1. Step 1: Understand the Query resolver

   The Query resolver returns a user object with id 1 and name "Alice".

2. Step 2: Understand the User type resolver

   The User resolver for fullName appends " Smith" to the parent's name, resulting in "Alice Smith".

3. Final Answer:

   { "user": { "fullName": "Alice Smith" } } -> Option D

4. Quick Check:

   fullName = parent.name + " Smith" [OK]

Hint: User resolver uses parent data to build fullName [OK]

Common Mistakes:

• Forgetting to use parent argument in field resolver
• Expecting fullName to be directly in Query resolver
• Assuming missing resolver causes error

4. Consider this resolver code snippet:

const resolvers = {
  Query: {
    posts: () => fetchPosts()
  },
  Post: {
    author: () => fetchAuthor()
  }
};

What is the main problem with this resolver organization?

medium

A. The schema is missing a Subscription resolver

B. The Post.author resolver ignores the parent post and fetches unrelated author data

C. Resolvers must be async functions, but these are not

D. The Query.posts resolver should be inside Mutation

Solution

1. Step 1: Analyze Post.author resolver

   The author resolver does not use the parent post argument, so it cannot fetch the correct author for each post.

2. Step 2: Understand resolver context

   Field resolvers should use the parent argument to access related data; ignoring it causes wrong or unrelated data.

3. Final Answer:

   The Post.author resolver ignores the parent post and fetches unrelated author data -> Option B

4. Quick Check:

   Use parent argument in nested resolvers [OK]

Hint: Nested resolvers must use parent to access related data [OK]

Common Mistakes:

• Ignoring parent argument in nested resolvers
• Misplacing Query resolvers inside Mutation
• Assuming all resolvers must be async

5. You want to organize resolvers for a GraphQL server with Queries, Mutations, and a custom type Book. Which structure below best supports maintainability and scalability?

hard

A. const resolvers = { Query: {...}, Mutation: {...} }; // no Book resolvers

B. const resolvers = { allResolvers: {...} };

C. const resolvers = { Query: {...}, Mutation: {...}, Book: {...} };

D. const resolvers = { Book: {...} }; // no Query or Mutation

Solution

1. Step 1: Identify best practice for resolver organization

   Grouping resolvers by operation type (Query, Mutation) and by custom types (Book) keeps code clear and modular.

2. Step 2: Compare options

   const resolvers = { Query: {...}, Mutation: {...}, Book: {...} }; clearly separates concerns and allows easy updates and scaling.

3. Final Answer:

   const resolvers = { Query: {...}, Mutation: {...}, Book: {...} }; -> Option C

4. Quick Check:

   Separate resolvers by operation and type [OK]

Hint: Group resolvers by Query, Mutation, and types for best structure [OK]

Common Mistakes:

• Putting all resolvers in one object without grouping
• Omitting resolvers for custom types
• Ignoring Mutation resolvers