Field-level cost analysis in GraphQL - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is field-level cost analysis in GraphQL?

Field-level cost analysis is a way to measure and control the cost of each field requested in a GraphQL query to prevent expensive queries from overloading the server.

beginner

Why is field-level cost analysis important in GraphQL APIs?

It helps protect the server from heavy or malicious queries by limiting resource use, ensuring fair usage, and improving API reliability.

intermediate

How can you assign cost to fields in a GraphQL schema?

You can assign a numeric cost value to each field, often using directives or middleware, to represent how expensive it is to resolve that field.

beginner

What happens if a GraphQL query exceeds the allowed cost limit?

The server rejects the query and returns an error, preventing the execution of expensive queries that could harm performance.

intermediate

Name one common method to implement field-level cost analysis in GraphQL servers.

Using query analysis middleware that calculates the total cost before executing the query and rejects it if it exceeds a set threshold.

What does field-level cost analysis help prevent in GraphQL APIs?

A Overloading the server with expensive queries

B Syntax errors in queries

C Unauthorized access to data

D Slow network connections

Field-level cost analysis helps prevent expensive queries from overloading the server by measuring and limiting query cost.

How is cost usually assigned to fields in GraphQL?

A By counting the number of characters in the field name

B By the order fields appear in the query

C By the size of the returned data only

D By assigning numeric cost values representing resource use

Cost is assigned as numeric values to represent how resource-intensive resolving each field is.

What is a typical response when a query exceeds the cost limit?

A The server rejects the query with an error

B The server returns partial data

C The server executes the query anyway

D The server delays the query execution

Queries exceeding the cost limit are rejected to protect server performance.

Which of these is a benefit of field-level cost analysis?

A Improves query syntax

B Prevents denial of service attacks

C Automatically caches query results

D Encrypts data in transit

By limiting expensive queries, field-level cost analysis helps prevent denial of service attacks.

What tool can be used to implement field-level cost analysis in GraphQL?

A CSS frameworks

B Database indexing

C Query analysis middleware

D HTML validators

Query analysis middleware calculates query cost before execution and enforces limits.

Explain what field-level cost analysis is and why it is useful in GraphQL APIs.

Think about how servers can get overloaded by complex queries.

Describe how you would implement field-level cost analysis in a GraphQL server.

Consider how to measure and check query cost before running it.

Practice

1. What is the main purpose of using the @cost directive in GraphQL field-level cost analysis?

easy

A. To rename a field in the schema

B. To define the data type of a field

C. To specify the default value of a field

D. To assign a numeric cost to each field to track resource usage

Solution

1. Step 1: Understand the purpose of field-level cost analysis

   Field-level cost analysis helps monitor and limit resource use by assigning costs to fields.

2. Step 2: Identify the role of the @cost directive

   The @cost directive assigns a numeric complexity cost to each field to estimate query cost.

3. Final Answer:

   To assign a numeric cost to each field to track resource usage -> Option D

4. Quick Check:

   @cost assigns cost = A [OK]

Hint: Remember: @cost tracks resource use per field [OK]

Common Mistakes:

• Confusing cost with data type definition
• Thinking @cost renames fields
• Assuming it sets default values

2. Which of the following is the correct syntax to add a cost directive with complexity 5 to a GraphQL field named books?

easy

A. books: [Book] @cost(complexity: 5)

B. books: [Book] @cost(5)

C. books: [Book] @cost(complexity=5)

D. books: [Book] @cost { complexity: 5 }

Solution

1. Step 1: Recall the correct directive syntax

   The @cost directive uses parentheses with named arguments, e.g., @cost(complexity: 5).

2. Step 2: Check each option's syntax

   books: [Book] @cost(complexity: 5) uses correct syntax with named argument and colon. The other three options use incorrect syntax forms.

3. Final Answer:

   books: [Book] @cost(complexity: 5) -> Option A

4. Quick Check:

   Correct directive syntax = B [OK]

Hint: Use parentheses and colon for directive args: @cost(complexity: 5) [OK]

Common Mistakes:

• Using equal sign instead of colon
• Omitting parentheses
• Using braces instead of parentheses

3. Given the schema snippet:

type Query {
  users: [User] @cost(complexity: 2, multipliers: ["first"])
}

input UserFilter {
  first: Int
}

And the query:

{ users(first: 3) { id name } }

What is the total cost of this query assuming id and name fields have cost 1 each?

medium

A. 3

B. 6

C. 8

D. 5

Solution

1. Step 1: Calculate base complexity and multipliers

   Base complexity is 2. The multiplier is the argument "first" with value 3, so multiply 2 * 3 = 6.

2. Step 2: Add cost of requested fields

   Fields id and name each cost 1, total 2. Add to 6 gives 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   2 * 3 + 1 + 1 = 8 [OK]

Hint: Multiply complexity by argument, then add field costs [OK]

Common Mistakes:

• Ignoring multipliers
• Not adding field costs
• Multiplying fields cost instead of adding

4. Consider this incorrect directive usage:

type Query {
  posts: [Post] @cost(complexity: "high")
}

What is the main error here?

medium

A. The complexity value must be an integer, not a string

B. The field name posts is invalid

C. The directive @cost cannot be used on lists

D. The directive syntax is missing parentheses

Solution

1. Step 1: Check the type of complexity argument

   The complexity argument expects an integer value, but "high" is a string.

2. Step 2: Verify other parts of the directive usage

   The field name and directive usage are valid; parentheses are present.

3. Final Answer:

   The complexity value must be an integer, not a string -> Option A

4. Quick Check:

   Complexity expects integer = D [OK]

Hint: Complexity must be a number, not text [OK]

Common Mistakes:

• Using string instead of integer for complexity
• Thinking directive can't be on lists
• Missing parentheses in directive

5. You have a GraphQL field comments with @cost(complexity: 1, multipliers: ["limit"]). The query requests comments(limit: 4) with subfields text and author, each costing 2. What is the total cost of this query?

hard

A. 12

B. 8

C. 10

D. 6

Solution

1. Step 1: Calculate base complexity with multiplier

   Base complexity is 1. Multiplier is argument "limit" with value 4, so 1 * 4 = 4.

2. Step 2: Add cost of subfields

   Subfields text and author each cost 2, total 4. Add to 4 gives 8.

3. Step 3: Verify the total

   Subfields are added flatly without further multiplication by list size: 4 (base) + 4 (subfields) = 8.

4. Final Answer:

   8 -> Option B

5. Quick Check:

   1*4 + (2+2) = 8 [OK]

Hint: Add base cost times multiplier plus subfields cost [OK]

Common Mistakes:

• Multiplying subfields cost by multiplier (e.g., getting 20)
• Adding costs without multiplier
• Confusing which costs to multiply