Query complexity analysis in GraphQL - Mini Project: Build & Apply

Query Complexity Analysis in GraphQL

📖 Scenario: You are working on a GraphQL API for a book store. To keep the API fast and prevent very expensive queries, you want to analyze the complexity of queries before running them.This project will guide you to set up a simple query complexity analysis using a basic scoring system.

🎯 Goal: Build a GraphQL query complexity analyzer that assigns a score to queries based on the fields requested. This helps to understand how complex a query is and avoid very costly queries.

📋 What You'll Learn

Create a GraphQL schema with types for Book and Author.

Add a query type with a books field returning a list of Book.

Define a complexity scoring function that assigns a score to each field.

Calculate the total complexity score for a sample query.

💡 Why This Matters

🌍 Real World

Query complexity analysis helps prevent very expensive or slow queries in GraphQL APIs, improving performance and protecting backend resources.

💼 Career

Understanding query complexity is important for backend developers and API engineers to build efficient and secure GraphQL services.

1

Define the GraphQL schema with Book and Author types

Create a GraphQL schema string called schema that defines a Book type with fields title (String) and author (Author). Define an Author type with fields name (String) and age (Int). Also define a Query type with a books field returning a list of Book.

GraphQL

# Define the GraphQL schema string with Book, Author, and Query types
# Your code here

Hint

Use triple quotes to create a multi-line string for the schema. Define the types exactly as specified.

2

Create a complexity score map for fields

Create a dictionary called field_complexity that assigns complexity scores: 'title' = 1, 'author' = 5, 'name' = 1, and 'age' = 1.

GraphQL

schema = '''
type Book {
  title: String
  author: Author
}

type Author {
  name: String
  age: Int
}

type Query {
  books: [Book]
}
'''

# Create the field_complexity dictionary
# Your code here

Hint

Use a Python dictionary with the exact keys and values given.

3

Write a function to calculate query complexity

Write a function called calculate_complexity that takes a list of field names called fields and returns the total complexity score by summing the scores from field_complexity. Use a for loop with variable field to iterate over fields.

GraphQL

schema = '''
type Book {
  title: String
  author: Author
}

type Author {
  name: String
  age: Int
}

type Query {
  books: [Book]
}
'''

field_complexity = {
    'title': 1,
    'author': 5,
    'name': 1,
    'age': 1
}

def calculate_complexity(fields):
    # Your code here

Hint

Initialize a total variable to 0, loop over fields, add each field's complexity score, and return the total.

4

Calculate complexity for a sample query

Create a list called sample_query_fields with these exact fields: 'title', 'author', 'name'. Then create a variable called query_score that stores the result of calling calculate_complexity(sample_query_fields).

GraphQL

schema = '''
type Book {
  title: String
  author: Author
}

type Author {
  name: String
  age: Int
}

type Query {
  books: [Book]
}
'''

field_complexity = {
    'title': 1,
    'author': 5,
    'name': 1,
    'age': 1
}

def calculate_complexity(fields):
    total = 0
    for field in fields:
        total += field_complexity.get(field, 0)
    return total

# Create sample_query_fields list and calculate query_score
# Your code here

Hint

Define the list with the exact fields and call the function with that list.

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