Bidirectional relationships in GraphQL - Time & Space Complexity

Time Complexity: Bidirectional relationships

O(n * m)

Understanding Time Complexity

When working with bidirectional relationships in GraphQL, it's important to understand how the time to fetch data grows as the related data grows.

We want to know how the number of operations changes when we query connected data in both directions.

Scenario Under Consideration

Analyze the time complexity of the following GraphQL query fetching bidirectional relationships.

query {
  authors {
    id
    name
    books {
      id
      title
      author {
        id
        name
      }
    }
  }
}
    

This query fetches authors, their books, and for each book, the author again, showing a bidirectional link.

Identify Repeating Operations

Look for repeated data fetching steps in the query.

• Primary operation: Loop over all authors, then for each author loop over their books, then for each book fetch the author again.
• How many times: The author list is traversed once, books are traversed for each author, and author info is fetched again for each book.

How Execution Grows With Input

As the number of authors and books grows, the operations increase accordingly.

Input Size (n authors, m books per author)	Approx. Operations
10 authors, 5 books each	10 + (10 * 5) + (10 * 5) = 10 + 50 + 50 = 110
100 authors, 5 books each	100 + (100 * 5) + (100 * 5) = 100 + 500 + 500 = 1100
1000 authors, 5 books each	1000 + (1000 * 5) + (1000 * 5) = 1000 + 5000 + 5000 = 11000

Pattern observation: The operations grow roughly in proportion to the number of authors times the number of books per author.

Final Time Complexity

Time Complexity: O(n * m)

This means the time grows proportionally to the number of authors multiplied by the number of books each author has.

Common Mistake

[X] Wrong: "Fetching the author inside each book doesn't add extra cost because it's the same author."

[OK] Correct: Even if it's the same author, the query repeats fetching author data for every book, so the operations add up with each book.

Interview Connect

Understanding how bidirectional data fetching scales helps you design efficient queries and avoid slow responses in real apps.

Self-Check

What if we removed fetching the author inside each book? How would the time complexity change?

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