Info argument in GraphQL - Deep Dive

Overview - Info argument

What is it?

The Info argument in GraphQL is a special object passed to resolver functions. It contains details about the current query, such as the fields requested, the schema, and the execution context. This helps resolvers understand what data the client wants and how to fetch or compute it efficiently. It is automatically provided by the GraphQL server during query execution.

Why it matters

Without the Info argument, resolvers would not know which parts of the data the client requested, leading to fetching unnecessary data or inefficient processing. This could slow down applications and increase server load. The Info argument enables smarter data fetching and better performance, making GraphQL queries faster and more precise.

Where it fits

Before learning about the Info argument, you should understand basic GraphQL concepts like schemas, types, and resolvers. After mastering the Info argument, you can explore advanced topics like query optimization, schema stitching, and custom directives that use query details for dynamic behavior.

Mental Model

Core Idea

The Info argument is a detailed map of the current GraphQL query that guides resolvers on what data to fetch and how to respond.

Think of it like...

Imagine a waiter taking your order at a restaurant. The Info argument is like the waiter’s notepad showing exactly what dishes you want, so the kitchen prepares only those items without guessing or making extras.

┌─────────────────────────────┐
│        Resolver Function     │
│                             │
│  Receives:                  │
│  - Parent data              │
│  - Arguments from client    │
│  - Info argument (query map)│
│                             │
│  Uses Info to decide:       │
│  - Which fields to fetch    │
│  - How to optimize fetching │
└─────────────┬───────────────┘
              │
              ▼
    ┌───────────────────────┐
    │ GraphQL Query Details  │
    │ - Requested fields     │
    │ - Schema info          │
    │ - Execution context    │
    └───────────────────────┘

Build-Up - 6 Steps

1

Foundation

What is the Info Argument

Concept: Introduce the Info argument as a special parameter in GraphQL resolvers.

In GraphQL, every resolver function can receive four parameters: parent, args, context, and info. The Info argument is the fourth parameter. It contains information about the current query, such as which fields the client requested and details about the schema. This helps the resolver understand the query better.

Result

Resolvers have access to detailed query information automatically.

Understanding that the Info argument exists and what it contains is the first step to writing smarter resolvers.

2

Foundation

Basic Structure of the Info Argument

Concept: Learn the main parts of the Info argument object.

The Info argument includes properties like fieldName (the current field being resolved), fieldNodes (AST nodes of the query), returnType (expected type), parentType (type of the parent object), schema (the full GraphQL schema), fragments (named fragments in the query), rootValue, and operation (the whole query operation).

Result

You can inspect the Info object to see exactly what data the client asked for.

Knowing the structure of Info lets you pick the right details to optimize data fetching.

3

Intermediate

Using Info to Optimize Data Fetching

🤔Before reading on: do you think resolvers always fetch all data or only requested fields? Commit to your answer.

Concept: Learn how to use Info to fetch only requested fields from databases or APIs.

By examining info.fieldNodes and info.fragments, you can find out exactly which fields the client wants. This allows you to build database queries that fetch only those fields, reducing data transfer and improving performance. For example, if the client only wants 'name' and 'age', you don't fetch 'address' or 'phone'.

Result

Resolvers fetch minimal data matching the query, improving speed and reducing load.

Understanding how to read requested fields from Info is key to efficient GraphQL servers.

4

Intermediate

Info Argument in Nested Resolvers

🤔Before reading on: do you think Info changes for nested fields or stays the same? Commit to your answer.

Concept: Explore how Info adapts when resolving nested fields in a query.

When a query has nested fields, each resolver receives its own Info argument relevant to its field. This means nested resolvers can also see what subfields are requested. This helps each resolver fetch exactly what it needs, even deep in the query tree.

Result

Each resolver gets precise query info for its part of the data.

Knowing that Info is context-specific per resolver helps design modular and efficient data fetching.

5

Advanced

Using Info for Query Complexity Analysis

🤔Before reading on: do you think Info can help prevent expensive queries? Commit to your answer.

Concept: Learn how Info can be used to analyze and limit query complexity to protect servers.

By parsing info.fieldNodes and operation details, you can calculate how complex a query is (e.g., how many fields and nested levels). This lets you reject or throttle queries that are too expensive, preventing server overload or denial-of-service attacks.

Result

Servers can protect themselves by understanding query cost via Info.

Using Info for security and performance safeguards is a powerful advanced technique.

6

Expert

Info Argument Internals and AST Usage

🤔Before reading on: do you think Info contains raw query text or a structured form? Commit to your answer.

Concept: Deep dive into how Info uses the GraphQL Abstract Syntax Tree (AST) to represent queries.

The Info argument contains fieldNodes, which are AST nodes representing the query structure. These nodes are parsed from the query text into a tree format that resolvers can traverse. Understanding this lets you manipulate or analyze queries programmatically, enabling advanced features like dynamic field resolution or custom directives.

Result

You can programmatically inspect and manipulate queries at a structural level.

Knowing that Info exposes the AST unlocks powerful customization and optimization possibilities.

Under the Hood

When a GraphQL query is received, the server parses it into an Abstract Syntax Tree (AST). During execution, each resolver is called with the Info argument containing parts of this AST relevant to that resolver's field. This allows the resolver to see exactly what the client requested, including nested fields and fragments. The Info object also links to the schema and execution context, enabling resolvers to make informed decisions.

Why designed this way?

The Info argument was designed to provide resolvers with rich context without requiring them to parse raw query strings themselves. This separation of concerns allows the GraphQL engine to handle parsing and validation, while resolvers focus on data fetching. It also enables advanced features like query analysis and optimization by exposing the AST and schema details.

┌───────────────┐
│ Client Query  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Query Parser  │
│ (creates AST) │
└──────┬────────┘
       │
       ▼
┌─────────────────────────────┐
│ GraphQL Execution Engine     │
│                             │
│ Calls Resolver with:         │
│ - parent                    │
│ - args                      │
│ - context                   │
│ - info (AST nodes + schema) │
└─────────────┬───────────────┘
              │
              ▼
      ┌───────────────┐
      │ Resolver Code │
      └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does the Info argument contain the raw query text? Commit to yes or no.

Common Belief: Many think Info contains the raw GraphQL query string as text.

Reality: Info contains a parsed, structured form of the query called the Abstract Syntax Tree (AST), not raw text.

Why it matters: Treating Info as raw text leads to inefficient parsing and misunderstanding of how to extract requested fields.

Quick: Do all resolvers receive the same Info object? Commit to yes or no.

Common Belief: Some believe the Info argument is the same for every resolver in a query.

Reality: Each resolver receives an Info object specific to its field and position in the query tree.

Why it matters: Assuming a single Info object can cause bugs when trying to access nested field info.

Quick: Can you modify the Info argument to change the query? Commit to yes or no.

Common Belief: Some think you can change the Info argument to alter the query execution.

Reality: Info is read-only and reflects the query structure; modifying it does not affect execution.

Why it matters: Trying to mutate Info wastes effort and can cause confusion about query behavior.

Quick: Does using Info always make resolvers slower? Commit to yes or no.

Common Belief: Some assume accessing Info adds significant overhead and slows down resolvers.

Reality: Accessing Info is lightweight and enables optimizations that usually improve overall performance.

Why it matters: Avoiding Info due to performance fears can lead to inefficient data fetching.

Expert Zone

1

Info.fieldNodes can contain multiple nodes when fragments are used, requiring careful merging of requested fields.

2

The returnType in Info helps resolvers understand if they should return a list, scalar, or object, guiding data shaping.

3

Info.fragments allows access to named fragments, enabling reusable query parts to be handled dynamically.

When NOT to use

In very simple GraphQL servers with fixed queries and no nested fields, using Info for optimization may add unnecessary complexity. In such cases, straightforward resolvers without Info inspection suffice. For complex queries or performance-critical apps, Info is essential.

Production Patterns

In production, Info is used to build dynamic database queries that fetch only requested fields, implement query complexity limits to prevent abuse, and support schema stitching by inspecting query structure. It also enables advanced caching strategies by understanding exactly what data is requested.

Connections

Abstract Syntax Tree (AST)

Info contains the AST nodes of the GraphQL query.

Understanding ASTs from programming languages helps grasp how Info represents query structure internally.

REST API Query Parameters

Info helps GraphQL resolvers know which fields to fetch, similar to how REST APIs use query parameters to specify fields.

Knowing how REST APIs filter data by parameters clarifies why Info is crucial for selective data fetching in GraphQL.

Database Query Optimization

Info enables building optimized database queries by knowing exactly which fields are requested.

Understanding database indexing and query planning helps appreciate how Info-driven resolvers improve performance.

Common Pitfalls

#1 Fetching all data regardless of requested fields.

Wrong approach:

function resolver(parent, args, context, info) {
return database.getAllUserData();
}

Correct approach:

function resolver(parent, args, context, info) {
const requestedFields = getRequestedFields(info);
return database.getUserData(requestedFields);
}

Root cause:

Not using Info to determine which fields the client requested leads to over-fetching.

#2 Assuming Info is the same for all resolvers in a query.

Wrong approach:

function resolverA(parent, args, context, info) {
console.log(info.fieldName); // 'user'
}
function resolverB(parent, args, context, info) {
console.log(info.fieldName); // also 'user' (incorrect assumption)
}

Correct approach:

function resolverA(parent, args, context, info) {
console.log(info.fieldName); // 'user'
}
function resolverB(parent, args, context, info) {
console.log(info.fieldName); // 'name' or actual field
}

Root cause:

Misunderstanding that Info is specific to each resolver's field.

#3 Trying to modify Info to change query behavior.

Wrong approach:

info.fieldNodes[0].selectionSet.selections.push(newField); // attempt to add field

Correct approach:

// Instead, modify schema or use directives to change query behavior before execution.

Root cause:

Info is read-only and reflects the parsed query; it cannot be changed at runtime.

Key Takeaways

The Info argument is a powerful object passed to GraphQL resolvers containing detailed query structure and schema information.

Using Info allows resolvers to fetch only the data requested by clients, improving performance and reducing unnecessary work.

Each resolver receives its own Info object tailored to its field, enabling precise control even in nested queries.

Info exposes the query as an Abstract Syntax Tree (AST), enabling advanced query analysis and optimization.

Understanding and using Info effectively is essential for building efficient, secure, and scalable GraphQL servers.