Many-to-many relationships in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Querying many-to-many relationships with GraphQL

Given a GraphQL schema where Students and Courses have a many-to-many relationship through enrollments, what is the expected output of this query?

query {
  students {
    name
    courses {
      title
    }
  }
}

Assume the data has one student named "Alice" enrolled in "Math" and "Science" courses.

A [{"name": "Alice", "courses": [{"title": "Math"}]}]

B [{"name": "Alice", "courses": [{"title": "Math"}, {"title": "Science"}]}]

C [{"name": "Alice"}]

D []

💡 Hint

Think about how many courses Alice is enrolled in and how GraphQL returns nested objects.

The query fetches all students with their enrolled courses. Since Alice is enrolled in both Math and Science, both courses appear nested under her name.

🧠 Conceptual

intermediate

Understanding many-to-many relationship tables

In a many-to-many relationship between Authors and Books, which table correctly represents the join table?

A A table named <em>author_books</em> with columns <code>author_id</code> and <code>book_id</code>.

B A table named <em>books</em> with columns <code>author_name</code> and <code>book_title</code>.

C A table named <em>authors</em> with columns <code>author_name</code> and <code>book_title</code>.

D A table named <em>author_book_titles</em> with columns <code>author_name</code> and <code>book_title</code>.

💡 Hint

Think about how many-to-many relationships are stored using IDs in a separate table.

The join table stores pairs of IDs from both tables to link authors and books without duplicating data.

📝 Syntax

advanced

Correct GraphQL schema for many-to-many

Which GraphQL type definition correctly models a many-to-many relationship between Users and Groups?

A type User { id: ID! groups: Group } type Group { id: ID! users: User }

B type User { id: ID! group: Group } type Group { id: ID! user: User }

C type User { id: ID! groups: [Group!]! } type Group { id: ID! users: [User!]! }

D type User { id: ID! groups: Group! } type Group { id: ID! users: User! }

💡 Hint

Remember that many-to-many means lists on both sides.

Option C uses lists of non-nullable Group and User types on both sides, correctly modeling many-to-many.

❓ optimization

advanced

Optimizing many-to-many GraphQL queries

To reduce database load when querying many-to-many relationships in GraphQL, which approach is best?

A Avoid using GraphQL and switch to REST API.

B Query each related entity separately without batching.

C Fetch all data in one big query without filtering.

D Use DataLoader to batch and cache database requests for related entities.

💡 Hint

Think about how to avoid repeated database calls for the same data.

DataLoader batches and caches requests, reducing duplicate queries and improving performance.

🔧 Debug

expert

Debugging missing data in many-to-many GraphQL query

A GraphQL query for users and their groups returns users but the groups field is always empty. The schema is correct. What is the most likely cause?

A The resolver for the <code>groups</code> field is missing or returns an empty list.

B The database has no users stored.

C The GraphQL query syntax is invalid.

D The <code>users</code> field is not defined in the schema.

💡 Hint

Check the resolver functions for nested fields.

If the groups field resolver is missing or returns empty, the query returns empty groups even if users exist.

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