Express integration in GraphQL - Step-by-Step Execution

Concept Flow - Express integration

Start Express Server

↓

Define GraphQL Schema

↓

Create GraphQL Resolver Functions

↓

Setup GraphQL Middleware in Express

↓

Receive HTTP Request

↓

GraphQL Middleware Processes Query

↓

Execute Resolver Functions

↓

Send Response to Client

↓

End

This flow shows how Express server integrates GraphQL by defining schema, resolvers, middleware, then handling requests and sending responses.

Execution Sample

GraphQL

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`type Query { hello: String }`);

const root = { hello: () => 'Hello world!' };

const app = express();
app.use('/graphql', graphqlHTTP({ schema: schema, rootValue: root, graphiql: true }));
app.listen(4000);

This code sets up an Express server with a GraphQL endpoint that returns 'Hello world!' for the 'hello' query.

Execution Table

Step	Action	Input	Process	Output
1	Start Express server	null	Listen on port 4000	Server running on port 4000
2	Receive HTTP request	{ query: '{ hello }' }	Pass request to /graphql middleware	Request forwarded to GraphQL middleware
3	GraphQL middleware parses query	{ hello }	Validate and parse query	Parsed query object
4	Execute resolver	hello field	Call root.hello()	Return "Hello world!"
5	Send response	Result from resolver	Format JSON response	{"data":{"hello":"Hello world!"}}
6	End request	Response sent	Close connection	Ready for next request

💡 Request completed and response sent, server continues listening

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
request	undefined	{ query: '{ hello }' }	{ query: '{ hello }' }	undefined (request handled)
parsedQuery	undefined	undefined	{ hello }	{ hello }
resolverResult	undefined	undefined	Hello world!	Hello world!
response	undefined	undefined	undefined	{"data":{"hello":"Hello world!"}}

Key Moments - 3 Insights

Why does the server keep running after sending the response?

Because Express listens continuously on the port (Step 1) and only closes the connection for each request after sending the response (Step 6), allowing it to handle more requests.

How does the GraphQL middleware know which resolver to call?

The middleware parses the query (Step 3) and matches fields like 'hello' to functions in the root resolver object (Step 4).

What happens if the query is invalid?

The middleware will return an error response instead of calling resolvers, stopping execution before Step 4.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after Step 4?

A Parsed query object

B Server running on port 4000

C "Hello world!"

D Formatted JSON response

💡 Hint

Check the 'Output' column at Step 4 in the execution_table

At which step does the server send the JSON response back to the client?

A Step 5

B Step 2

C Step 3

D Step 6

💡 Hint

Look for 'Send response' action in the execution_table

If the query was invalid, which step would most likely not happen?

A Step 3: Parse query

B Step 4: Execute resolver

C Step 2: Receive HTTP request

D Step 6: End request

💡 Hint

Invalid queries stop execution before resolvers run, see key_moments explanation

Concept Snapshot

Express integration with GraphQL:
- Define GraphQL schema and resolvers
- Use express-graphql middleware on a route
- Server listens for HTTP requests
- Middleware parses queries and calls resolvers
- Responses sent as JSON
- Server stays running for more requests

Full Transcript

This visual execution trace shows how Express integrates GraphQL. First, the Express server starts and listens on port 4000. When a client sends a GraphQL query to the /graphql endpoint, Express passes the request to the GraphQL middleware. The middleware parses and validates the query, then calls the matching resolver function. The resolver returns data, which the middleware formats as a JSON response and sends back to the client. The server then closes the request connection but keeps running to handle more requests. Key moments include understanding how the middleware matches queries to resolvers and why the server stays running after sending a response.

Practice

1. What is the main purpose of using express-graphql middleware in an Express app?

easy

A. To create a new database connection

B. To connect a GraphQL schema to the Express server for handling HTTP requests

C. To serve static files like images and CSS

D. To replace Express with a GraphQL server

Solution

1. Step 1: Understand the role of middleware in Express

   Middleware functions in Express handle requests and responses, adding features to the server.

2. Step 2: Identify what express-graphql does

   This middleware connects a GraphQL schema and resolvers to Express, enabling GraphQL queries over HTTP.

3. Final Answer:

   To connect a GraphQL schema to the Express server for handling HTTP requests -> Option B

4. Quick Check:

   express-graphql middleware = Connect GraphQL to Express [OK]

Hint: Middleware connects GraphQL schema to Express HTTP server [OK]

Common Mistakes:

• Thinking it creates a database connection
• Confusing it with static file serving
• Assuming it replaces Express entirely

2. Which of the following is the correct way to use express-graphql middleware in an Express app?

easy

A. app.get('/graphql', graphqlHTTP(mySchema));

B. app.use('/graphql', graphqlHTTP(schema, rootResolver));

C. app.post('/graphql', graphqlHTTP({ rootValue: rootResolver }));

D. app.use('/graphql', graphqlHTTP({ schema: mySchema, rootValue: rootResolver, graphiql: true }));

Solution

1. Step 1: Recall the correct syntax for express-graphql middleware

   The middleware is used with app.use and takes an options object with keys like schema, rootValue, and graphiql.

2. Step 2: Check each option for correct usage

   app.use('/graphql', graphqlHTTP({ schema: mySchema, rootValue: rootResolver, graphiql: true })); correctly uses app.use with an options object including schema, rootValue, and graphiql. Others either misuse method or pass wrong arguments.

3. Final Answer:

   app.use('/graphql', graphqlHTTP({ schema: mySchema, rootValue: rootResolver, graphiql: true })); -> Option D

4. Quick Check:

   express-graphql needs options object with schema and rootValue [OK]

Hint: Use app.use with options object for express-graphql [OK]

Common Mistakes:

• Using app.get or app.post instead of app.use
• Passing schema and rootValue as separate arguments
• Omitting the graphiql option during development

3. Given this Express setup with GraphQL:

const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { buildSchema } = require('graphql');

const schema = buildSchema(`
  type Query {
    hello: String
  }
`);

const root = {
  hello: () => 'Hello world!'
};

const app = express();
app.use('/graphql', graphqlHTTP({ schema: schema, rootValue: root, graphiql: false }));

app.listen(4000);

What will be the JSON response to this POST query to /graphql?

{"query": "{ hello }"}

medium

A. {"data":{"hello":"Hello world!"}}

B. {"error":"Query not found"}

C. {"data":{"hello":null}}

D. SyntaxError

Solution

1. Step 1: Understand the schema and resolver

   The schema defines a Query type with a field hello returning a String. The root resolver returns 'Hello world!' for hello.

2. Step 2: Analyze the query and response

   The query requests { hello }. The resolver returns 'Hello world!', so the response JSON includes this under data.

3. Final Answer:

   {"data":{"hello":"Hello world!"}} -> Option A

4. Quick Check:

   Query hello returns 'Hello world!' [OK]

Hint: Query matches resolver return value exactly [OK]

Common Mistakes:

• Expecting an error when schema and resolver match
• Confusing null with missing data
• Assuming graphiql affects response format

4. You wrote this Express GraphQL setup:

app.use('/graphql', graphqlHTTP({
  schema: mySchema,
  rootValue: rootResolver
}));

But when you send queries, you get an error: Cannot POST /graphql. What is the likely cause?

medium

A. You did not enable the body parser middleware for JSON

B. You did not define the schema correctly

C. You used app.get instead of app.use

D. You forgot to import express-graphql

Solution

1. Step 1: Understand the error message

   The error 'Cannot POST /graphql' means Express does not recognize POST requests to that route.

2. Step 2: Check middleware setup for POST data

   GraphQL POST requests send JSON body. Express needs body parser middleware (like express.json()) to parse JSON bodies before graphqlHTTP.

3. Final Answer:

   You did not enable the body parser middleware for JSON -> Option A

4. Quick Check:

   Missing JSON body parser causes POST errors [OK]

Hint: Always add express.json() before graphqlHTTP for POST [OK]

Common Mistakes:

• Assuming graphqlHTTP handles JSON parsing automatically
• Confusing app.use with app.get
• Blaming schema definition for routing errors

5. You want to add a new Query field user(id: ID!): User to your GraphQL schema in Express. The User type has fields id and name. Which of the following shows the correct way to extend the schema and resolver for this, assuming you have a getUserById function?

hard

A. Schema: type Query { user(id: String): User } and resolver: { user: (id) => getUserById(id) }

B. Schema: type Query { user: User } and resolver: { user: () => getUserById() }

C. Schema: type Query { user(id: ID!): User } and resolver: { user: ({id}) => getUserById(id) }

D. Schema: type Query { user(id: ID!): User } and resolver: { user: (args) => getUserById(args) }

Solution

1. Step 1: Define schema with required argument and User type

   The schema must declare user(id: ID!): User to require an ID argument and return a User object.

2. Step 2: Write resolver matching argument destructuring

   The resolver function receives an object with arguments, so destructure {id} and pass it to getUserById.

3. Final Answer:

   Schema: type Query { user(id: ID!): User } and resolver: { user: ({id}) => getUserById(id) } -> Option C

4. Quick Check:

   Schema arg ID! and resolver destructure args [OK]

Hint: Destructure args object in resolver for required ID [OK]

Common Mistakes:

• Not marking ID as non-null with !
• Passing args incorrectly in resolver
• Using wrong argument type in schema