Single endpoint architecture in GraphQL - Step-by-Step Execution

Concept Flow - Single endpoint architecture

Client sends request

↓

Single GraphQL Endpoint

↓

Parse query

↓

Resolve fields

↓

Fetch data from DB or services

↓

Assemble response

↓

Send response back to client

The client sends all requests to one GraphQL endpoint, which parses and resolves the query, fetches data, and returns the response.

Execution Sample

GraphQL

query {
  user(id: "1") {
    name
    posts {
      title
    }
  }
}

A client requests a user's name and their posts' titles through a single GraphQL endpoint.

Execution Table

Step	Action	Details	Result
1	Receive request	Client sends query to /graphql endpoint	Query received
2	Parse query	Extract fields: user(id: "1") { name, posts { title } }	Parsed query tree
3	Resolve 'user' field	Fetch user with id=1 from database	User data retrieved
4	Resolve 'name' field	Extract 'name' from user data	User name obtained
5	Resolve 'posts' field	Fetch posts related to user id=1	Posts data retrieved
6	Resolve 'title' field	Extract 'title' from each post	Post titles obtained
7	Assemble response	Combine user name and post titles into JSON	Response ready
8	Send response	Return JSON to client	Client receives data
9	End	All fields resolved and response sent	Execution complete

💡 All requested fields resolved and response sent to client

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
query	null	Parsed query tree	Parsed query tree	Parsed query tree
userData	null	{id:1, name:'Alice'}	{id:1, name:'Alice', posts:[...]}	{id:1, name:'Alice', posts:[{title:'Post1'}, {title:'Post2'}]}
response	null	null	null	{"user":{"name":"Alice","posts":[{"title":"Post1"},{"title":"Post2"}]}}

Key Moments - 3 Insights

Why does the client send all queries to a single endpoint instead of multiple URLs?

Because the single endpoint parses the query to know exactly what data is needed, avoiding multiple endpoints and simplifying communication, as shown in execution_table steps 1 and 2.

How does the server know which fields to fetch from the database?

The server parses the query to identify requested fields (step 2), then resolves each field by fetching only the necessary data (steps 3-6), avoiding extra data retrieval.

What happens if a requested field is not available in the database?

The resolver for that field returns null or an error, but the rest of the query continues resolving, ensuring partial data can still be returned, as implied by the stepwise resolution in execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 4?

A Response ready

B User name obtained

C Posts data retrieved

D Query received

💡 Hint

Check the 'Result' column in row for step 4 in execution_table

At which step does the server fetch posts related to the user?

A Step 3

B Step 7

C Step 5

D Step 2

💡 Hint

Look at the 'Action' and 'Details' columns in execution_table for fetching posts

If the client requested only the user's name, which steps would be skipped?

A Steps 5 and 6

B Steps 3 and 4

C Steps 7 and 8

D No steps skipped

💡 Hint

Refer to execution_table steps resolving 'posts' and 'title' fields

Concept Snapshot

Single endpoint architecture in GraphQL:
- One URL handles all queries
- Client sends query specifying needed data
- Server parses query, resolves fields
- Fetches only requested data
- Returns combined JSON response
Simplifies API and reduces over-fetching

Full Transcript

In single endpoint architecture for GraphQL, the client sends all requests to one endpoint. The server parses the query to understand what data is requested. It then resolves each field by fetching data from the database or services. After gathering all requested data, the server assembles it into a JSON response and sends it back to the client. This approach simplifies communication by using one endpoint and fetching only the data needed, avoiding multiple URLs and over-fetching.