Bidirectional relationships in GraphQL - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a bidirectional relationship field in GraphQL schema.

GraphQL

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

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

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

A@relation(name: "BooksByAuthor")

B@relation(name: "AuthorBooks")

C@relation(name: "AuthorToBooks")

D@relation(name: "BooksAuthor")

Attempts:

3 left

💡 Hint

Common Mistakes

Omitting the @relation directive causes the relationship to be unidirectional.

Using inconsistent relation names on both sides.

The @relation(name: "BooksByAuthor") directive defines the bidirectional link between Author.books and Book.author.

2fill in blank

medium

Complete the code to define the inverse side of the bidirectional relationship.

GraphQL

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

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

A@relation(name: "AuthorBooks")

B@relation(name: "BooksAuthor")

C@relation(name: "AuthorToBooks")

D@relation(name: "BooksByAuthor")

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different relation name breaks the bidirectional link.

Forgetting to add the @relation directive on one side.

The @relation(name: "BooksByAuthor") directive on Book.author matches the name used on Author.books to create a bidirectional link.

3fill in blank

hard

Fix the error in the bidirectional relationship by completing the missing directive.

GraphQL

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

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

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

A@relation(name: "BooksByAuthor")

B@relation(name: "AuthorToBooks")

C@relation(name: "BooksAuthor")

D@relation(name: "AuthorBooks")

Attempts:

3 left

💡 Hint

Common Mistakes

Using different relation names on each side.

Missing the @relation directive on one side.

The correct relation name @relation(name: "BooksByAuthor") must be used to match the inverse side and fix the bidirectional link.

4fill in blank

hard

Fill both blanks to define a bidirectional relationship with explicit foreign key field.

GraphQL

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

type Book {
  id: ID!
  title: String!
  authorId: ID!
  author: Author[2]
}

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

A@relation(name: "BooksByAuthor")

B@relation(name: "AuthorBooks")

C@relation(name: "BooksByAuthor", fields: [authorId], references: [id])

D@relation(name: "AuthorBooks", fields: [authorId], references: [id])

Attempts:

3 left

💡 Hint

Common Mistakes

Using different relation names.

Omitting fields and references on the foreign key side.

The @relation(name: "BooksByAuthor") on Author.books and @relation(name: "BooksByAuthor", fields: [authorId], references: [id]) on Book.author define a bidirectional relationship with explicit foreign key.

5fill in blank

hard

Fill all three blanks to define a bidirectional relationship with custom relation name and explicit foreign key.

GraphQL

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

type Post {
  id: ID!
  content: String!
  userId: ID!
  user: User[2][3]
}

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

A@relation(name: "UserPosts")

B@relation(name: "UserPosts", fields: [userId]

C, references: [id])

D@relation(name: "PostsByUser")

Attempts:

3 left

💡 Hint

Common Mistakes

Using different relation names on each side.

Forgetting to add references on the foreign key side.

The @relation(name: "UserPosts") on User.posts and @relation(name: "UserPosts", fields: [userId]) plus , references: [id] on Post.user define a bidirectional relationship with a custom name and explicit foreign key.

Practice

1. What is the main purpose of bidirectional relationships in GraphQL schemas?

easy

A. To connect two types so you can query related data from both sides

B. To make the schema run faster by caching data

C. To encrypt data between client and server

D. To limit the number of queries a client can make

Solution

1. Step 1: Understand what bidirectional relationships do

   They link two types so you can access related data from either type easily.

2. Step 2: Compare options to this purpose

   Only To connect two types so you can query related data from both sides describes this linking and querying from both sides.

3. Final Answer:

   To connect two types so you can query related data from both sides -> Option A

4. Quick Check:

   Bidirectional relationships = connect types both ways [OK]

Hint: Think: Can I get related data from both types? That's bidirectional [OK]

Common Mistakes:

• Confusing bidirectional with performance optimization
• Thinking it encrypts data
• Assuming it limits queries

2. Which of the following is the correct way to define a bidirectional relationship between Author and Book types in GraphQL SDL?

easy

A. type Author { books: Book } type Book { author: [Author] }

B. type Author { books: [Author] } type Book { author: [Book] }

C. type Author { books: Book } type Book { author: Book }

D. type Author { books: [Book] } type Book { author: Author }

Solution

1. Step 1: Check the relationship types

   An author can have many books, so books should be a list of Book. Each book has one author, so author is a single Author.

2. Step 2: Match this to options

   Only type Author { books: [Book] } type Book { author: Author } correctly uses [Book] for books and Author for author.

3. Final Answer:

   type Author { books: [Book] } type Book { author: Author } -> Option D

4. Quick Check:

   List on many side, single on one side = type Author { books: [Book] } type Book { author: Author } [OK]

Hint: Many side uses list [], one side uses single type [OK]

Common Mistakes:

• Using single type where list is needed
• Swapping list and single types
• Using wrong type names

3. Given the following GraphQL schema snippet:

type User { posts: [Post] } type Post { author: User }

What will be the result of this query?

{ user { posts { author { id } } } }

medium

A. { "data": { "user": { "posts": [{ "author": { "id": "..." } }, ...] } } }

B. Syntax error due to missing fields

C. { "data": { "user": { "posts": null } } }

D. Runtime error because of circular reference

Solution

1. Step 1: Understand the schema and query

   User has posts, each post has an author. Query asks for user's posts and each post's author id.

2. Step 2: Predict the query result

   Since fields exist and are linked bidirectionally, the query returns posts with author ids nested properly.

3. Final Answer:

   { "data": { "user": { "posts": [{ "author": { "id": "..." } }, ...] } } } -> Option A

4. Quick Check:

   Bidirectional query returns nested data correctly [OK]

Hint: Bidirectional means nested data is accessible both ways [OK]

Common Mistakes:

• Thinking circular references cause runtime errors
• Assuming missing fields cause syntax errors
• Expecting null when data exists

4. You have this GraphQL schema:

type Category { products: [Product] } type Product { category: Category }

But your query for category { products { category { id } }} returns null for category inside products. What is the likely cause?

medium

A. The products field should not be a list

B. GraphQL does not support nested bidirectional queries

C. The category field in Product is not properly resolved or linked

D. The query syntax is invalid

Solution

1. Step 1: Analyze the schema and query

   Schema defines bidirectional links. Query asks for category's products and each product's category id.

2. Step 2: Identify why nested category is null

   If nested category is null, likely the resolver for category in Product is missing or incorrect.

3. Final Answer:

   The category field in Product is not properly resolved or linked -> Option C

4. Quick Check:

   Missing resolver causes null nested fields [OK]

Hint: Null nested fields often mean missing resolver functions [OK]

Common Mistakes:

• Assuming GraphQL can't do nested bidirectional queries
• Thinking list types cause nulls
• Blaming query syntax without error

5. You want to model a bidirectional relationship between Employee and Manager where each employee has one manager, and each manager can have many employees. Which schema correctly models this with bidirectional fields?

hard

A. type Employee { manager: Employee } type Manager { employees: [Manager] }

B. type Employee { manager: Manager } type Manager { employees: [Employee] }

C. type Employee { manager: Manager } type Manager { employees: Employee }

D. type Employee { manager: [Manager] } type Manager { employees: Employee }

Solution

1. Step 1: Understand the relationship

   Each employee has one manager (single), each manager has many employees (list).

2. Step 2: Match schema fields to this

   Employee's manager is a single Manager. Manager's employees is a list of Employee.

3. Final Answer:

   type Employee { manager: Manager } type Manager { employees: [Employee] } -> Option B

4. Quick Check:

   One-to-many bidirectional = single on one side, list on other [OK]

Hint: One side single type, other side list type for one-to-many [OK]

Common Mistakes:

• Swapping list and single types
• Using wrong types for fields
• Confusing employee and manager roles