Why resolvers connect schema to data in GraphQL - Visual Breakdown

Concept Flow - Why resolvers connect schema to data

Client sends query

↓

GraphQL Server receives query

↓

Schema defines types & fields

↓

Resolver functions run

↓

Resolvers fetch or compute data

↓

Data returned to client

The flow shows how a client query goes through the schema, then resolvers fetch the actual data, and finally the data is sent back.

Execution Sample

GraphQL

type Query {
  book(id: ID!): Book
}

const resolvers = {
  Query: {
    book: (parent, args) => {
      return database.findBookById(args.id);
    }
  }
};

This schema defines a book query, and the resolver fetches the book data by ID from the database.

Execution Table

Step	Action	Input	Resolver Called	Data Fetched	Output
1	Receive query	{ book(id: "1") }	N/A	N/A	N/A
2	Match schema field	book(id: "1")	Query.book	N/A	N/A
3	Call resolver	id = "1"	Query.book	database.findBookById("1")	Book object with id 1
4	Return data	Book object	N/A	N/A	{ book: { id: "1", title: "GraphQL Guide" } }

💡 Query resolved and data returned to client

Variable Tracker

Variable	Start	After Step 3	Final
args.id	undefined	"1"	"1"
resolver result	undefined	Book object with id 1	Book object with id 1

Key Moments - 2 Insights

Why does the resolver get called after matching the schema field?

Because the schema defines what fields exist, but the resolver is the function that actually fetches or computes the data for that field, as shown in execution_table step 3.

What happens if the resolver does not return data?

The client will get null or an error for that field, since the resolver is responsible for providing the data, as seen in the output column of step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the resolver called when the query is processed?

A database.findBookById

B Query.book

C Client.query

D Schema.book

💡 Hint

Check the 'Resolver Called' column in step 3 of the execution table.

At which step does the resolver fetch data from the database?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Data Fetched' column in the execution table.

If the resolver returned null, what would change in the execution table output?

A Output would show null instead of a Book object

B Resolver Called would be different

C Input would change

D Data Fetched would be empty string

💡 Hint

Refer to the 'Output' column in step 4 of the execution table.

Concept Snapshot

GraphQL schema defines the shape of data.
Resolvers are functions that fetch or compute data for schema fields.
When a query runs, resolvers connect schema fields to actual data.
Without resolvers, schema fields have no data.
Resolvers receive arguments and return data to the client.

Full Transcript

In GraphQL, the client sends a query to the server. The server uses the schema to understand what data is requested. Each field in the schema has a resolver function that knows how to get the actual data. The resolver runs with the query arguments, fetches data from a database or other source, and returns it. This data is then sent back to the client. This process connects the schema to real data, making GraphQL queries work.