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

Need a 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

Need a 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

Need a 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

Need a hint?

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