Why relationships model real data in GraphQL - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a GraphQL type for a user with an ID field.

GraphQL

type User { id: [1] }

Drag options to blanks, or click blank then click option'

AID!

BString

CInt

DBoolean

Attempts:

3 left

💡 Hint

Common Mistakes

Using String instead of ID for unique identifiers.

Omitting the non-nullable exclamation mark.

The ID! type is used to uniquely identify a user and is non-nullable.

2fill in blank

medium

Complete the code to add a posts field to the User type representing a list of posts.

GraphQL

type User { posts: [1] }

Drag options to blanks, or click blank then click option'

A[Post!]

BPost

C[Post]

DPost!

Attempts:

3 left

💡 Hint

Common Mistakes

Using a single Post type instead of a list.

Not marking the posts as non-nullable inside the list.

The [Post!] syntax means a list of non-null Post objects, modeling multiple posts related to a user.

3fill in blank

hard

Fix the error in the Post type by completing the author field to link back to the User type.

GraphQL

type Post { author: [1] }

Drag options to blanks, or click blank then click option'

A[User]

BID

CUser!

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using a list of users instead of a single user.

Using String or ID instead of User type.

The User! type means each post must have exactly one author, linking the post to a user.

4fill in blank

hard

Fill both blanks to define a Comment type with an author and a post it belongs to.

GraphQL

type Comment { author: [1] post: [2] }

Drag options to blanks, or click blank then click option'

AUser!

BPost!

C[User]

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using lists instead of single types.

Using String instead of User or Post types.

Each comment has one author (User!) and belongs to one post (Post!), modeling real relationships.

5fill in blank

hard

Fill all three blanks to define a schema with User, Post, and Comment types showing their relationships.

GraphQL

type User { posts: [1] } type Post { author: [2] comments: [3] }

Drag options to blanks, or click blank then click option'

A[Post!]

BUser!

C[Comment!]

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up lists and single types.

Using nullable types where non-null is needed.

The User has many posts ([Post!]), each Post has one author (User!) and many comments ([Comment!]), modeling real-world data relationships.

Practice

1. Why do relationships between types in GraphQL help model real-world data?

easy

A. They store data in separate databases automatically.

B. They make the data types run faster in queries.

C. They remove the need for any fields in types.

D. They connect different data types to show how things relate in real life.

Solution

1. Step 1: Understand the purpose of relationships in data

   Relationships link different data types to represent how real-world things connect.

2. Step 2: Identify how GraphQL uses relationships

   GraphQL uses fields in types to show these connections clearly without duplicating data.

3. Final Answer:

   They connect different data types to show how things relate in real life. -> Option D

4. Quick Check:

   Relationships = Real-world connections [OK]

Hint: Think of relationships as real-life links between things [OK]

Common Mistakes:

• Confusing relationships with performance improvements
• Thinking relationships remove fields
• Assuming relationships create separate databases

2. Which of the following is the correct way to define a relationship field in a GraphQL type?

easy

A. type Book { author -> Author }

B. type Book { author = Author }

C. type Book { author: Author }

D. type Book { author: "Author" }

Solution

1. Step 1: Recall GraphQL field syntax

   Fields are defined as fieldName: TypeName without extra symbols or quotes.

2. Step 2: Check each option

   type Book { author: Author } uses correct syntax with colon and type name. Others use invalid symbols or quotes.

3. Final Answer:

   type Book { author: Author } -> Option C

4. Quick Check:

   Field syntax = name: Type [OK]

Hint: Use colon (:) between field and type in GraphQL [OK]

Common Mistakes:

• Using equals (=) instead of colon
• Using arrows (->) instead of colon
• Putting type name in quotes

3. Given the GraphQL types:

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

What will the query <code>{ author(id: "1") { name books { title } } }?

medium

A. Only the list of books without author info

B. Author's name and a list of their books' titles

C. Only the author's name

D. An error because of circular references

Solution

1. Step 1: Analyze the query structure

   The query asks for an author by id, then requests the author's name and their books' titles.

2. Step 2: Understand the relationship fields

   The author type has a books field which is a list of Book types, so nested fields like title can be fetched.

3. Final Answer:

   Author's name and a list of their books' titles -> Option B

4. Quick Check:

   Nested fields return connected data [OK]

Hint: Nested fields fetch related data in one query [OK]

Common Mistakes:

• Thinking circular references cause errors in GraphQL
• Expecting only one level of data returned
• Ignoring nested fields in query

4. Identify the error in this GraphQL type definition:

type User { id: ID name: String posts: Post }

Assuming a user can have many posts, what is wrong?

medium

A. posts field should be a list type, like [Post]

B. posts field should be a scalar type like String

C. posts field should be named postList

D. posts field should be inside a separate type

Solution

1. Step 1: Understand the data relationship

   A user can have many posts, so posts must hold multiple Post objects.

2. Step 2: Check the field type

   The field posts is defined as a single Post, but it should be a list of Post, written as [Post].

3. Final Answer:

   posts field should be a list type, like [Post] -> Option A

4. Quick Check:

   Multiple items = list type [OK]

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

Common Mistakes:

• Using single type for multiple items
• Changing field name unnecessarily
• Thinking fields must be in separate types

5. You want to model a social network where users can follow many other users. Which GraphQL type definition correctly models this relationship?

hard

A. type User { id: ID name: String followers: [User] following: [User] }

B. type User { id: ID name: String followers: User following: User }

C. type User { id: ID name: String followers: String following: String }

D. type User { id: ID name: String followers: [String] following: [String] }

Solution

1. Step 1: Understand the relationship type

   Users can follow many other users, so followers and following must be lists of User type.

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

   type User { id: ID name: String followers: [User] following: [User] } correctly uses lists of User for both followers and following. Others use single User or String types incorrectly.

3. Final Answer:

   type User { id: ID name: String followers: [User] following: [User] } -> Option A

4. Quick Check:

   Many-to-many = lists of same type [OK]

Hint: Use lists of the same type for many-to-many relationships [OK]

Common Mistakes:

• Using single User type for multiple followers
• Using String instead of User type
• Confusing field types with scalar lists