One-to-many relationships in GraphQL - Step-by-Step Execution

Concept Flow - One-to-many relationships

Start Query

↓

Fetch Parent Entity

↓

For each Parent

↓

Fetch Related Many Children

↓

Combine Parent with Children

↓

Return Full Result Set

The query starts by fetching a parent entity, then for each parent, it fetches all related child entities, combining them to return a full one-to-many result.

Execution Sample

GraphQL

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

This GraphQL query fetches an author by ID and all their related books, showing a one-to-many relationship.

Execution Table

Step	Action	Evaluation	Result
1	Start query execution	Query requests author with id '1'	Ready to fetch author
2	Fetch author	Look up author with id '1'	{id: "1", name: "Jane Doe"}
3	Fetch books	Find all books where authorId = '1'	[{id: "101", title: "GraphQL Basics"}, {id: "102", title: "Advanced GraphQL"}]
4	Combine data	Attach books array to author object	{id: "1", name: "Jane Doe", books: [...]}
5	Return result	Send combined author and books data	Final result sent to client

💡 All related books fetched and combined with author; query completes successfully

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
author	null	{id: "1", name: "Jane Doe"}	{id: "1", name: "Jane Doe"}	{id: "1", name: "Jane Doe", books: [...]}	{id: "1", name: "Jane Doe", books: [...]}
books	null	null	[{id: "101", title: "GraphQL Basics"}, {id: "102", title: "Advanced GraphQL"}]	[{id: "101", title: "GraphQL Basics"}, {id: "102", title: "Advanced GraphQL"}]	[{id: "101", title: "GraphQL Basics"}, {id: "102", title: "Advanced GraphQL"}]

Key Moments - 3 Insights

Why do we fetch books after fetching the author?

Because books are related to the author, we first need the author's ID to find all books linked to that author, as shown in steps 2 and 3 of the execution_table.

How do we know which books belong to the author?

Books have an authorId field matching the author's id. Step 3 filters books where authorId equals '1', ensuring only related books are fetched.

What does the final combined result look like?

The final result is the author object with a 'books' field containing an array of all related book objects, as shown in step 4 and the variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'author' after Step 2?

A {id: "1", name: "Jane Doe"}

B null

C {id: "101", title: "GraphQL Basics"}

D [{id: "101", title: "GraphQL Basics"}, {id: "102", title: "Advanced GraphQL"}]

💡 Hint

Check the 'author' variable in variable_tracker after Step 2.

At which step are the related books fetched?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column in execution_table for fetching books.

If the author had no books, how would the 'books' variable look after Step 3?

A null

B []

C [{id: "101", title: "GraphQL Basics"}]

D undefined

💡 Hint

Think about how an empty list of related items is represented in GraphQL results.

Concept Snapshot

One-to-many relationships in GraphQL:
- Query parent entity (e.g., author)
- Fetch all related children (e.g., books) linked by foreign key
- Combine children as an array field in parent
- Result returns parent with array of related children
- Enables fetching nested related data in one query

Full Transcript

This visual execution shows how a GraphQL query retrieves a one-to-many relationship. The query starts by requesting an author by ID. The system fetches the author data first. Then it fetches all books linked to that author by matching authorId. These books are combined into an array attached to the author object. Finally, the combined data is returned to the client. Variables 'author' and 'books' update step-by-step to show data retrieval and combination. Key moments clarify why fetching order matters and how related data is linked. The quiz tests understanding of variable states and query steps.

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