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

Challenge - 5 Problems

❓ query_result

intermediate

Querying a one-to-many relationship in GraphQL

Given a GraphQL schema where Author has many Books, what will be the result of this query?

query {
  authors {
    name
    books {
      title
    }
  }
}

GraphQL

type Author {
  id: ID!
  name: String!
  books: [Book!]!
}

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

# Sample data:
# authors = [{id: "1", name: "Alice"}, {id: "2", name: "Bob"}]
# books = [{id: "a", title: "GraphQL Basics", authorId: "1"}, {id: "b", title: "Advanced GraphQL", authorId: "1"}, {id: "c", title: "Intro to Databases", authorId: "2"}]

A [{"name": "Alice", "books": [{"title": "GraphQL Basics"}, {"title": "Advanced GraphQL"}]}, {"name": "Bob", "books": [{"title": "Intro to Databases"}]}]

B [{"name": "Alice", "books": [{"title": "Intro to Databases"}]}, {"name": "Bob", "books": [{"title": "GraphQL Basics"}, {"title": "Advanced GraphQL"}]}]

C [{"name": "Alice", "books": []}, {"name": "Bob", "books": []}]

D [{"name": "Alice"}, {"name": "Bob"}]

💡 Hint

Remember that books are linked to authors by authorId.

The query returns each author with their books. Alice has two books, Bob has one.

🧠 Conceptual

intermediate

Understanding one-to-many relationships in GraphQL schema

Which statement correctly describes a one-to-many relationship in a GraphQL schema?

A A type has no fields referencing other types.

B A type has a field that returns a single scalar value only.

C A type has a field that returns a union of unrelated types.

D A type has a field that returns a list of another type, representing multiple related items.

💡 Hint

Think about how multiple related items are represented.

One-to-many means one item relates to many items of another type, so the field returns a list.

📝 Syntax

advanced

Identify the syntax error in this GraphQL schema for one-to-many

Which option contains a syntax error in defining a one-to-many relationship?

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

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

A The field 'authorId' should be a list type '[ID!]' instead of 'ID!'.

B The field 'books' should be a list type '[Book!]' instead of 'Book!'.

C The type 'Book' must have a field 'author' of type 'Author!'.

D The field 'name' should be nullable 'String' instead of 'String!'.

💡 Hint

One-to-many means one author has many books.

The 'books' field must be a list to represent many books, so it should be '[Book!]!'.

❓ optimization

advanced

Optimizing nested queries in one-to-many GraphQL relationships

Given a one-to-many relationship between Author and Books, which approach best reduces over-fetching when querying authors with their books?

A Request only the fields needed from both authors and books in the query selection set.

B Always request all fields from authors and books to avoid missing data.

C Use multiple separate queries for authors and books instead of nested queries.

D Request only authors and ignore books to reduce data size.

💡 Hint

GraphQL allows selecting exactly what you want.

Selecting only needed fields avoids fetching unnecessary data, improving performance.

🔧 Debug

expert

Debugging a missing nested list in GraphQL one-to-many query

Why does this query return authors without their books?

query {
  authors {
    name
    books {
      title
    }
  }
}

Schema snippet:

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

A The 'name' field is not requested correctly.

B The query is missing an argument to filter books by author.

C The 'books' field is not a list type; it should be '[Book!]!' to return multiple books.

D The schema is missing the 'Book' type definition.

💡 Hint

Check the type of the 'books' field in the schema.

The 'books' field is defined as a single 'Book' instead of a list, so it returns null or one book, not many.

Practice

1. In GraphQL, what does a one-to-many relationship mean?
One-to-many connects one item to many related items. Which statement is true?

easy

A. Many parents share one child.

B. Each child has multiple parents.

C. One parent has many children linked to it.

D. Parents and children are unrelated.

Solution

1. Step 1: Understand the meaning of one-to-many

   One-to-many means one item (parent) connects to many items (children).

2. Step 2: Match the description to options

   One parent has many children linked to it. correctly states one parent has many children, matching the definition.

3. Final Answer:

   One parent has many children linked to it. -> Option C

4. Quick Check:

   One-to-many = One parent, many children [OK]

Hint: Remember: one parent, many children in one-to-many [OK]

Common Mistakes:

• Confusing one-to-many with many-to-one
• Thinking children have multiple parents
• Assuming parents and children are unrelated

2. Which of the following is the correct GraphQL schema snippet to represent a one-to-many relationship between Author and Book?

easy

A. type Author { id: ID! name: String! books: [Book!]! } type Book { id: ID! title: String! authorId: ID! }

B. type Author { id: ID! name: String! book: Book } type Book { id: ID! title: String! author: Author }

C. type Author { id: ID! name: String! books: Book } type Book { id: ID! title: String! authorId: ID! }

D. type Author { id: ID! name: String! books: Book! } type Book { id: ID! title: String! authorId: ID! }

Solution

1. Step 1: Identify list type for many children

   In GraphQL, a one-to-many uses a list type like [Book!]! for multiple books.

2. Step 2: Check each option's books field

   type Author { id: ID! name: String! books: [Book!]! } type Book { id: ID! title: String! authorId: ID! } uses books: [Book!]! correctly; others use single Book or wrong types.

3. Final Answer:

   type Author { id: ID! name: String! books: [Book!]! } type Book { id: ID! title: String! authorId: ID! } -> Option A

4. Quick Check:

   List type for many children = [Type!]! [OK]

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

Common Mistakes:

• Using single type instead of list for many children
• Missing non-null ! on list or items
• Confusing field names or types

3. Given this GraphQL query and schema, what will be the output?

type Author { id: ID! name: String! books: [Book!]! } type Book { id: ID! title: String! authorId: ID! }

Query:

{ author(id: "1") { name books { title } } }

Assuming author 1 has two books titled "Book A" and "Book B".

medium

A. {"author":null}

B. {"author":{"name":"Author One","books":{"title":"Book A"}}}

C. {"author":{"name":"Author One","books":null}}

D. {"author":{"name":"Author One","books":[{"title":"Book A"},{"title":"Book B"}]}}

Solution

1. Step 1: Understand the schema and query

   The author has a list of books; query requests author name and all book titles.

2. Step 2: Match expected output

   Author 1 has two books, so books field returns a list with two titles.

3. Final Answer:

   JSON with author name and books list of two titles -> Option D

4. Quick Check:

   One author, many books = list output [OK]

Hint: Lists in schema return arrays in query results [OK]

Common Mistakes:

• Expecting single object instead of list for books
• Assuming books field is null if empty
• Confusing null author with empty books

4. This GraphQL schema snippet has an error for one-to-many relationship. What is wrong?

type User { id: ID! name: String! posts: Post } type Post { id: ID! content: String! userId: ID! }

medium

A. The posts field should be a list type [Post!]! instead of Post.

B. The userId field should be removed from Post.

C. The name field in User should be optional.

D. The id fields should be of type String, not ID.

Solution

1. Step 1: Check the posts field type for one-to-many

   One user can have many posts, so posts must be a list, not a single Post.

2. Step 2: Verify other fields

   userId in Post is correct to link back; name optionality and id type are unrelated.

3. Final Answer:

   posts field must be a list [Post!]! -> Option A

4. Quick Check:

   One-to-many needs list type for many children [OK]

Hint: Use brackets [] for multiple related items in schema [OK]

Common Mistakes:

• Using single object instead of list for many children
• Removing foreign key fields mistakenly
• Changing unrelated field types

5. You want to design a GraphQL schema for a blog where each Category has many Posts, and each Post belongs to one Category. Which schema design correctly models this one-to-many relationship and allows querying all posts in a category?

hard

A. type Category { id: ID! name: String! post: Post } type Post { id: ID! title: String! category: Category } Query { posts: [Post!]! }

B. type Category { id: ID! name: String! posts: [Post!]! } type Post { id: ID! title: String! categoryId: ID! } Query { category(id: ID!): Category }

C. type Category { id: ID! name: String! posts: Post } type Post { id: ID! title: String! categoryId: ID! } Query { category(id: ID!): Category }

D. type Category { id: ID! name: String! posts: [Post] } type Post { id: ID! title: String! category: Category! } Query { category(id: ID!): Category }

Solution

1. Step 1: Model one-to-many with list in Category

   Category should have posts as a list [Post!]! to represent many posts.

2. Step 2: Use categoryId in Post to link back

   Post has categoryId to link to its single category, enabling queries from both sides.

3. Step 3: Check Query type for fetching category

   Query allows fetching category by id, then posts can be queried from category.

4. Final Answer:

   type Category { id: ID! name: String! posts: [Post!]! } type Post { id: ID! title: String! categoryId: ID! } Query { category(id: ID!): Category } -> Option B

5. Quick Check:

   List in parent + foreign key in child = one-to-many [OK]

Hint: Parent has list, child has foreign key ID for one-to-many [OK]

Common Mistakes:

• Using single Post instead of list in Category
• Missing foreign key in Post
• Incorrect Query type for fetching data