Relationship design patterns in GraphQL - Step-by-Step Execution

Concept Flow - Relationship design patterns

Define Entities

↓

Choose Relationship Type

↓

One-to-One

↓

Link Entities Directly

↓

One-to-Many

↓

Use List Field in One Entity

↓

Many-to-Many

↓

Create Join Entity or List Fields

↓

Query Relationships

↓

Return Related Data

Start by defining entities, then pick the relationship type (one-to-one, one-to-many, many-to-many), design fields accordingly, and finally query related data.

Execution Sample

GraphQL

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

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

Defines a one-to-many relationship where one Author has many Books, and each Book has one Author.

Execution Table

Step	Action	Entity State	Relationship Field	Result
1	Define Author entity	Author: {id, name}	books: [Book!]!	Author can have many Books
2	Define Book entity	Book: {id, title}	author: Author!	Each Book linked to one Author
3	Create Author instance	Author(id=1, name='Alice')	books: []	Author has no books yet
4	Create Book instance	Book(id=101, title='GraphQL Basics')	author: Author(1)	Book linked to Author Alice
5	Add Book to Author.books	Author(1).books = [Book(101)]	books updated	Author now has one book
6	Query Author with books	Author(1)	books: [Book(101)]	Returns Author Alice with her book
7	Query Book with author	Book(101)	author: Author(1)	Returns Book with Author Alice
8	End	-	-	Relationship setup complete

💡 All entities defined and linked; queries return related data as expected

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
Author	undefined	Author(id=1, name='Alice', books=[])	Author(id=1, name='Alice', books=[])	Author(id=1, name='Alice', books=[Book(101)])	Author(id=1, name='Alice', books=[Book(101)])
Book	undefined	undefined	Book(id=101, title='GraphQL Basics', author=Author(1))	Book(id=101, title='GraphQL Basics', author=Author(1))	Book(id=101, title='GraphQL Basics', author=Author(1))

Key Moments - 3 Insights

Why does the Author entity have a list of Books but each Book has only one Author?

Because this models a one-to-many relationship: one Author can write many Books, but each Book has only one Author. See execution_table rows 1, 2, and 5.

How do we link a Book to its Author in the data?

By setting the Book's author field to reference the Author instance, as shown in execution_table row 4.

What happens if we query an Author's books before adding any Book?

The books list is empty, meaning no related Books yet. See execution_table row 3.

Visual Quiz - 3 Questions

Look at the execution_table at step 5, what is the Author's books list?

A [Book(101)]

B []

C [Author(1)]

D undefined

💡 Hint

Check the 'Relationship Field' column at step 5 in execution_table

At which step is the Book linked to the Author?

A Step 3

B Step 4

C Step 6

D Step 2

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for when Book.author is set

If we remove the books field from Author, what relationship type is lost?

A One-to-One

B Many-to-Many

C One-to-Many

D No relationship

💡 Hint

Refer to concept_flow and execution_table rows 1 and 5 about the list field in Author

Concept Snapshot

Relationship design patterns in GraphQL:
- Define entities as types
- Use fields to represent relationships
- One-to-One: single object field
- One-to-Many: list field in one entity
- Many-to-Many: join entity or lists in both
- Query nested fields to get related data

Full Transcript

This visual execution shows how to design relationships in GraphQL schemas. We start by defining two entities: Author and Book. Author has a list field 'books' representing many Books, and Book has a single 'author' field linking back to Author. We create instances of Author and Book, link the Book to the Author by setting the author field, and add the Book to the Author's books list. Queries then return the Author with their books or a Book with its author. This models a one-to-many relationship. Key moments include understanding why Author has a list of Books and how linking is done by referencing instances. The quiz tests understanding of these steps and relationship types.

Practice

1. In GraphQL, which relationship pattern describes one item connected to many items, like one author having many books?

easy

A. One-to-many

B. Many-to-one

C. Many-to-many

D. One-to-one

Solution

1. Step 1: Understand relationship types

   One-to-many means one record links to many records, like one author to many books.

2. Step 2: Match example to pattern

   Since one author can have many books, this fits one-to-many.

3. Final Answer:

   One-to-many -> Option A

4. Quick Check:

   One author -> many books = One-to-many [OK]

Hint: One item linked to many items means one-to-many [OK]

Common Mistakes:

• Confusing many-to-many with one-to-many
• Thinking one-to-one fits multiple items
• Mixing up direction of relationship

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

easy

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

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

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

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

Solution

1. Step 1: Identify many-to-many syntax

   Many-to-many uses lists on both sides, so fields must be arrays like [Course!]! and [Student!]!.

2. Step 2: Check options for correct list syntax

   type Student { courses: [Course!]! } type Course { students: [Student!]! } uses lists with non-nullable items and non-nullable lists, which is correct GraphQL syntax.

3. Final Answer:

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

4. Quick Check:

   Lists on both sides = many-to-many syntax [OK]

Hint: Many-to-many uses lists on both types in GraphQL [OK]

Common Mistakes:

• Using single objects instead of lists for many-to-many
• Missing non-nullable markers (!)
• Confusing one-to-one syntax with many-to-many

3. Given this GraphQL schema snippet:

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

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

What will the query { author(id: "1") { books { title } } } return if author 1 has two books titled "A" and "B"?

medium

A. {"data":{"author":{"books":{"title":"A"}}}}

B. {"data":{"author":{"books":[{"title":"A"},{"title":"B"}]}}}

C. {"data":{"author":{"books":null}}}

D. {"errors":[{"message":"Field 'books' not found"}]}

Solution

1. Step 1: Understand schema and query

   Author has a list of books. Query asks for author with id "1" and their books' titles.

2. Step 2: Predict query result

   Since author 1 has two books "A" and "B", the books field returns a list with both titles.

3. Final Answer:

   {"data":{"author":{"books":[{"title":"A"},{"title":"B"}]}}} -> Option B

4. Quick Check:

   List of books with titles A and B returned [OK]

Hint: List fields return arrays of objects in GraphQL query results [OK]

Common Mistakes:

• Expecting a single book object instead of a list
• Assuming null if multiple books exist
• Confusing error with missing field

4. Consider this GraphQL type definition:

type User {
  id: ID!
  posts: Post
}

type Post {
  id: ID!
  content: String!
}

What is the main problem with this design if a user can have many posts?

medium

A. The 'posts' field should be a list, not a single Post object.

B. The 'id' field is missing in User type.

C. The 'content' field should be nullable.

D. The Post type should include a reference back to User.

Solution

1. Step 1: Analyze the 'posts' field type

   The 'posts' field is declared as a single Post, but users can have many posts.

2. Step 2: Identify correct type for multiple posts

   To represent many posts, 'posts' should be a list like [Post!]! instead of a single Post.

3. Final Answer:

   The 'posts' field should be a list, not a single Post object. -> Option A

4. Quick Check:

   Multiple posts need list type, not single object [OK]

Hint: Multiple related items need list type in GraphQL [OK]

Common Mistakes:

• Thinking single object can hold many items
• Ignoring list syntax for multiple relations
• Assuming missing fields cause this error

5. You want to model a social network in GraphQL where users can follow many other users and be followed by many users. Which relationship design pattern and schema snippet correctly represents this many-to-many self-relationship?

hard

A. type User { follower: User following: User } // single user on each side

B. type User { followers: [User] following: User } // mixed list and single user

C. type User { followers: User! following: User! } // non-null single user

D. type User { followers: [User!]! following: [User!]! } // both lists represent many-to-many

Solution

1. Step 1: Understand many-to-many self-relationship

   Users can follow many users and be followed by many users, so both sides need lists.

2. Step 2: Check schema for correct list usage

   type User { followers: [User!]! following: [User!]! } // both lists represent many-to-many uses lists for both followers and following, correctly modeling many-to-many self-relationship.

3. Final Answer:

   type User { followers: [User!]! following: [User!]! } -> Option D

4. Quick Check:

   Lists on both sides model many-to-many self-relationship [OK]

Hint: Self many-to-many needs lists on both fields [OK]

Common Mistakes:

• Using single User instead of list for followers/following
• Mixing list and single object types
• Forgetting non-nullable list syntax