Relationship design patterns in GraphQL - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a one-to-many relationship between Author and Book.

GraphQL

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

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

AID

BAuthor

CString

DBook

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same type as the parent (Author) instead of the related type (Book).

Using scalar types like String or ID instead of the related object type.

The books field in Author should be a list of Book objects to represent a one-to-many relationship.

2fill in blank

medium

Complete the code to define a many-to-many relationship between Student and Course.

GraphQL

type Student {
  id: ID!
  name: String!
  courses: [[1]!]!
}

type Course {
  id: ID!
  title: String!
  students: [Student!]!
}

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

AString

BCourse

CStudent

DID

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same type as the parent (Student) instead of the related type (Course).

Using scalar types like String or ID instead of the related object type.

The courses field in Student should be a list of Course objects to represent many-to-many relationships.

3fill in blank

hard

Fix the error in the code to correctly define a one-to-one relationship between User and Profile.

GraphQL

type User {
  id: ID!
  username: String!
  profile: [1]
}

type Profile {
  id: ID!
  bio: String
  user: User!
}

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

AProfile!

B[Profile!]

CString

DID

Attempts:

3 left

💡 Hint

Common Mistakes

Using a list type for a one-to-one relationship.

Omitting the non-nullable marker when the relationship is required.

The profile field should be a single Profile object, not a list, and it should be non-nullable to represent a one-to-one relationship.

4fill in blank

hard

Fill both blanks to define a bidirectional one-to-many relationship between Category and Product.

GraphQL

type Category {
  id: ID!
  name: String!
  products: [[1]!]!
}

type Product {
  id: ID!
  name: String!
  category: [2]!
}

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

AProduct

BCategory

CString

DID

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up the types in the list and single fields.

Using scalar types instead of object types.

The products field in Category is a list of Product objects, and the category field in Product is a single Category object, both non-nullable.

5fill in blank

hard

Fill all three blanks to define a many-to-many relationship with an intermediate type Enrollment between Student and Course.

GraphQL

type Student {
  id: ID!
  name: String!
  enrollments: [[1]!]!
}

type Course {
  id: ID!
  title: String!
  enrollments: [Enrollment!]!
}

type Enrollment {
  id: ID!
  student: [2]!
  course: [3]!
}

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

AEnrollment

BStudent

CCourse

DString

Attempts:

3 left

💡 Hint

Common Mistakes

Using scalar types instead of object types in relationships.

Mixing up the types in the intermediate type fields.

The enrollments fields in Student and Course reference the Enrollment type. The Enrollment type links back to Student and Course with non-nullable fields.

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