Query complexity analysis in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Calculate the total number of fields requested in a GraphQL query

Given this GraphQL query, how many fields in total are requested (including nested fields)?

{ user { id name posts { id title comments { id content } } } }

GraphQL

{ user { id name posts { id title comments { id content } } } }

A 7

B 8

C 10

D 9

💡 Hint

Count each field at every level, including nested ones.

The query requests: user(1), id(2), name(3), posts(4), posts.id(5), posts.title(6), posts.comments(7), posts.comments.id(8), posts.comments.content(9). Total fields: 9.

🧠 Conceptual

intermediate

Understanding query depth impact on complexity

Which statement best describes how query depth affects GraphQL query complexity?

A Query depth increases complexity exponentially because each nested field can multiply the number of requested fields.

B Query depth has no impact on complexity since only top-level fields count.

C Query depth decreases complexity because nested fields are cached.

D Query depth affects complexity linearly regardless of nested fields.

💡 Hint

Think about how nested fields multiply the total fields requested.

Each nested level can add multiple fields, causing the total number of fields to grow exponentially with depth.

📝 Syntax

advanced

Identify the syntax error in this GraphQL query

What error does this GraphQL query produce?

{ user(id: 1) { id name posts { id title comments { id content } } }

GraphQL

{ user(id: 1) { id name posts { id title comments { id content } } }

A RuntimeError: Field 'posts' does not exist

B TypeError: Argument 'id' must be a string

C SyntaxError: Missing closing brace '}'

D No error, query is valid

💡 Hint

Check if all braces are properly closed.

The query is missing the final closing brace '}' at the end, causing a syntax error.

❓ optimization

advanced

Optimizing a GraphQL query to reduce complexity

Which option reduces the query complexity the most while still fetching user id, name, and post titles?

GraphQL

{ user { id name posts { id title comments { id content } } } }

A { user { id name posts { title } } }

B { user { id name posts { id title comments { id } } } }

C { user { id name posts { id title comments { content } } } }

D { user { id name } }

💡 Hint

Remove fields that are not needed to reduce complexity.

Option A removes the comments field entirely and only fetches post titles, reducing nested fields and complexity.

🔧 Debug

expert

Diagnose why this GraphQL query causes performance issues

This query causes slow response times:

{ user { id name posts { id title comments { id content author { id name } } } } }

What is the main reason for the high complexity?

A The query uses deprecated fields causing server errors.

B The nested 'author' field inside comments causes deep recursion increasing complexity exponentially.

C The query is missing required arguments causing repeated retries.

D The query requests only top-level fields, so complexity is low.

💡 Hint

Look for deeply nested fields that multiply the number of requested fields.

The 'author' field inside comments adds another nested level, causing exponential growth in requested data and slowing performance.

Practice

1. What is the main purpose of query complexity analysis in GraphQL?

easy

A. To measure how resource-heavy a query is before execution

B. To change the data returned by a query

C. To write queries faster

D. To store query results in cache

Solution

1. Step 1: Understand query complexity analysis

   It estimates how much work a query will cause the server to do before running it.

2. Step 2: Identify the main goal

   This helps prevent very heavy queries that slow down or crash the server.

3. Final Answer:

   To measure how resource-heavy a query is before execution -> Option A

4. Quick Check:

   Query complexity = resource estimation [OK]

Hint: Think: Why check query cost before running? To protect server [OK]

Common Mistakes:

• Confusing complexity analysis with caching
• Thinking it changes query results
• Assuming it speeds up query writing

2. Which of the following is a correct way to define a complexity rule in a GraphQL server?

easy

A. Adding a complexity function to field definitions

B. Writing complexity inside the GraphQL query itself

C. Using @complexity directive in the query

D. Setting complexity in the client application

Solution

1. Step 1: Recall where complexity rules are set

   Complexity rules are added in the server schema code, usually as functions on fields.

2. Step 2: Eliminate wrong options

   Complexity is not set inside queries, directives, or client apps.

3. Final Answer:

   Adding a complexity function to field definitions -> Option A

4. Quick Check:

   Complexity rules = server schema code [OK]

Hint: Complexity rules live on server fields, not in queries [OK]

Common Mistakes:

• Trying to add complexity in the query text
• Using non-existent directives for complexity
• Setting complexity on client side

3. Given this GraphQL query and complexity rules:

{ user { posts { comments } } }

If user has complexity 1, posts complexity 5, and comments complexity 2, what is the total complexity?

medium

A. 8

B. 15

C. 7

D. 10

Solution

1. Step 1: Identify field complexities

   user = 1, posts = 5, comments = 2.

2. Step 2: Calculate for nested fields

   Nested field complexities are multiplied: 1 x 5 x 2 = 10.

3. Final Answer:

   10 -> Option D

4. Quick Check:

   Nested fields multiply complexity = 1*5*2=10 [OK]

Hint: Multiply all nested field complexities: 1 x 5 x 2 = 10 [OK]

Common Mistakes:

• Adding all numbers without multiplication
• Ignoring nested field multiplication
• Choosing sum instead of product for nested fields

4. You wrote a complexity function for a field but your server crashes on some queries. What is a likely cause?

medium

A. The query is missing required fields

B. You forgot to add the field to the schema

C. The complexity function returns a non-numeric value

D. The client sent an invalid query syntax

Solution

1. Step 1: Understand complexity function requirements

   Complexity functions must return numbers representing cost.

2. Step 2: Identify crash cause

   If the function returns a string or undefined, the server cannot calculate total complexity and crashes.

3. Final Answer:

   The complexity function returns a non-numeric value -> Option C

4. Quick Check:

   Complexity function must return number [OK]

Hint: Ensure complexity functions return numbers only [OK]

Common Mistakes:

• Returning strings or null from complexity functions
• Ignoring schema registration of fields
• Blaming client query syntax for server crashes

5. You want to limit your GraphQL server to reject queries with complexity over 100. Which approach correctly implements this?

hard

A. Modify client queries to never exceed 100 complexity

B. Add a complexity rule that calculates total cost and rejects queries above 100

C. Use a directive in queries to mark complexity limits

D. Increase server timeout to handle heavy queries

Solution

1. Step 1: Understand server-side complexity limiting

   The server must calculate query complexity and reject queries exceeding the limit.

2. Step 2: Evaluate options

   Only adding a complexity rule on the server can enforce this limit automatically.

3. Final Answer:

   Add a complexity rule that calculates total cost and rejects queries above 100 -> Option B

4. Quick Check:

   Server enforces limits via complexity rules [OK]

Hint: Limit complexity on server, not client or query text [OK]

Common Mistakes:

• Trying to limit complexity from client side
• Using query directives which don't enforce limits
• Increasing timeout instead of limiting complexity