Many-to-many relationships in GraphQL - Mini Project: Build & Apply

Many-to-many relationships in GraphQL

📖 Scenario: You are building a simple library system where books can have multiple authors, and authors can write multiple books. This is a classic many-to-many relationship.

🎯 Goal: Create a GraphQL schema that models the many-to-many relationship between Book and Author. You will define types and a linking type to connect them.

📋 What You'll Learn

Define a Book type with fields id (ID!), title (String!), and authors (list of Author)

Define an Author type with fields id (ID!), name (String!), and books (list of Book)

Create a linking type BookAuthor with fields bookId (ID!) and authorId (ID!) to represent the many-to-many relationship

Use appropriate GraphQL syntax for type definitions

💡 Why This Matters

🌍 Real World

Many-to-many relationships are common in real-world databases, such as students enrolled in multiple courses or products belonging to multiple categories.

💼 Career

Understanding how to model many-to-many relationships in GraphQL is essential for backend developers building APIs that reflect complex data relationships.

1

Define the Book type

Create a GraphQL type called Book with fields: id of type ID! and title of type String!.

GraphQL

# Define the Book type with id and title fields

Hint

Use type Book { id: ID! title: String! } syntax.

2

Define the Author type

Add a GraphQL type called Author with fields: id of type ID! and name of type String!.

GraphQL

type Book {
  id: ID!
  title: String!
}

# Define the Author type with id and name fields

Hint

Use type Author { id: ID! name: String! } syntax.

3

Add the linking type BookAuthor

Create a GraphQL type called BookAuthor with fields: bookId of type ID! and authorId of type ID! to link books and authors.

GraphQL

type Book {
  id: ID!
  title: String!
}

type Author {
  id: ID!
  name: String!
}

# Define the BookAuthor linking type

Hint

Use type BookAuthor { bookId: ID! authorId: ID! } syntax.

4

Add the many-to-many fields to Book and Author

Modify the Book type to add a field authors which is a list of Author. Modify the Author type to add a field books which is a list of Book.

GraphQL

type Book {
  id: ID!
  title: String!
  # Add authors field here
}

type Author {
  id: ID!
  name: String!
  # Add books field here
}

type BookAuthor {
  bookId: ID!
  authorId: ID!
}

Hint

Add authors: [Author] to Book and books: [Book] to Author.

Practice

1. In GraphQL, how do you represent a many-to-many relationship between two types, for example, Author and Book?

easy

A. By having a list of Book in Author and a list of Author in Book

B. By having a single field of Book in Author only

C. By using scalar fields only, no lists

D. By embedding Author inside Book as a string

Solution

1. Step 1: Understand many-to-many relationship in GraphQL

   Many-to-many means each Author can have many Books and each Book can have many Authors.

2. Step 2: Represent with lists on both types

   To model this, both Author and Book types should have a list field referencing the other type.

3. Final Answer:

   By having a list of Book in Author and a list of Author in Book -> Option A

4. Quick Check:

   Many-to-many = lists on both sides [OK]

Hint: Use lists on both types to link many items [OK]

Common Mistakes:

• Using a single object instead of a list
• Not linking both types with lists
• Using scalar fields instead of object references

2. Which of the following is the correct GraphQL schema snippet to define a many-to-many relationship between Student and Course?

easy

A. type Student { course: Course } type Course { student: Student }

B. type Student { courses: Course } type Course { students: Student }

C. type Student { courses: String } type Course { students: String }

D. type Student { courses: [Course!]! } type Course { students: [Student!]! }

Solution

1. Step 1: Check list syntax for many-to-many

   Many-to-many requires lists, so fields must be lists like [Course!]! and [Student!]!.

2. Step 2: Validate non-null and list usage

   type Student { courses: [Course!]! } type Course { students: [Student!]! } correctly uses non-null lists of non-null items, which is best practice.

3. Final Answer:

   type Student { courses: [Course!]! } type Course { students: [Student!]! } -> Option D

4. Quick Check:

   Lists with non-null = correct schema [OK]

Hint: Use square brackets for lists in GraphQL schema [OK]

Common Mistakes:

• Missing square brackets for lists
• Using singular fields instead of lists
• Using scalar types instead of object types

3. Given this GraphQL query on a many-to-many schema:

query { students { name courses { title } } }

What will the result include?

medium

A. A list of students with their names and a list of their enrolled courses' titles

B. Only student names without any course information

C. Only course titles without student names

D. An error because nested queries are not allowed

Solution

1. Step 1: Understand the query structure

   The query requests students with their name and nested courses with title.

2. Step 2: Interpret many-to-many data fetching

   Since courses is a list on Student, the result includes each student's name and their list of course titles.

3. Final Answer:

   A list of students with their names and a list of their enrolled courses' titles -> Option A

4. Quick Check:

   Nested lists fetch related data [OK]

Hint: Nested fields fetch linked many-to-many data [OK]

Common Mistakes:

• Expecting only flat data without nested lists
• Thinking nested queries cause errors
• Ignoring the many-to-many list structure

4. You wrote this GraphQL schema snippet:

type User { groups: Group } type Group { users: User }

Why does this cause problems in representing many-to-many relationships?

medium

A. Because the field names are incorrect

B. Because groups and users are not lists, so only one group or user can be linked

C. Because GraphQL does not allow circular references

D. Because the types are missing scalar fields

Solution

1. Step 1: Check field types for many-to-many

   Many-to-many requires lists on both sides, but here groups and users are single objects, not lists.

2. Step 2: Understand impact on data modeling

   This means each User can link to only one Group and vice versa, not many, so it breaks many-to-many.

3. Final Answer:

   Because groups and users are not lists, so only one group or user can be linked -> Option B

4. Quick Check:

   Lists needed for many-to-many [OK]

Hint: Use lists, not single objects, for many-to-many fields [OK]

Common Mistakes:

• Using single object fields instead of lists
• Assuming circular references cause errors
• Ignoring the need for lists in many-to-many

5. You have a many-to-many relationship between Artist and Album. You want to fetch all artists with their albums, but only include albums released after 2020. Which GraphQL query correctly applies this filter?

hard

A. query { artists { name albums { title releaseYear } where: { releaseYear > 2020 } } }

B. query { artists { name albums { title releaseYear filter: { releaseYear > 2020 } } } }

C. query { artists { name albums(where: { releaseYear_gt: 2020 }) { title releaseYear } } }

D. query { artists { name albums { title releaseYear } } filter: { releaseYear > 2020 } }

Solution

1. Step 1: Identify correct filter syntax in GraphQL

   GraphQL commonly uses arguments like where with conditions such as releaseYear_gt: 2020 to filter nested lists.

2. Step 2: Check query structure for filtering nested albums

   query { artists { name albums(where: { releaseYear_gt: 2020 }) { title releaseYear } } }

   correctly places the where argument inside the albums field to filter albums after 2020.

3. Final Answer:

   query { artists { name albums(where: { releaseYear_gt: 2020 }) { title releaseYear } } } -> Option C

4. Quick Check:

   Use where argument inside nested field [OK]

Hint: Apply filters as arguments inside nested fields [OK]

Common Mistakes:

• Placing filters outside nested fields
• Using invalid filter syntax
• Not filtering at the nested list level