Server middleware in GraphQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Middleware effect on query response

Consider a GraphQL server with middleware that adds a requestId field to the context for each request. Given the query below, what will be the output if the middleware correctly adds a unique requestId?

query GetUser {
  user(id: "1") {
    id
    name
    requestId
  }
}

Assume the user with id "1" has name "Alice".

A {"data": {"user": {"id": "1", "name": "Alice", "requestId": "req-123"}}}

B {"data": {"user": null}}

C {"data": {"user": {"id": "1", "name": "Alice"}}}

D {"errors": [{"message": "Field \"requestId\" not found on type User"}]}

💡 Hint

Think about the GraphQL schema and what fields are defined on the User type.

The requestId is added to the context by middleware but is not part of the User type in the schema. Therefore, querying requestId on user causes a schema validation error.

🧠 Conceptual

intermediate

Purpose of server middleware in GraphQL

What is the primary purpose of server middleware in a GraphQL server?

A To modify the GraphQL schema dynamically during query execution

B To intercept and process requests before they reach the resolver functions

C To generate client-side queries automatically

D To store data permanently in the database

💡 Hint

Think about what middleware usually does in web servers.

Middleware acts as a layer that can inspect, modify, or reject requests before they reach the GraphQL resolvers. It is not responsible for schema changes, client query generation, or data storage.

📝 Syntax

advanced

Identify the syntax error in middleware setup

Which option contains a syntax error in setting up Express middleware for a GraphQL server?

GraphQL

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

app.use('/graphql', (req, res, next) => {
  req.context = { user: 'admin' };
  next();
});

app.use('/graphql', graphqlHTTP({
  schema: mySchema,
  graphiql: true,
  context: req.context
}));

A The middleware function does not call next(), causing requests to hang

B The app.use calls should be combined into one call

C The context option in graphqlHTTP cannot access req.context directly like this

D The schema variable mySchema is not imported

💡 Hint

Consider how the context option is set in express-graphql.

The context option in graphqlHTTP must be a function or an object. Here, req.context is undefined at the time of middleware setup because req is not accessible outside the middleware function. The correct approach is to pass a function that receives req and returns the context.

🔧 Debug

advanced

Debugging middleware order issue

A developer notices that authentication middleware is not working as expected in their GraphQL server. The middleware is supposed to add a user object to the context, but resolvers receive undefined. What is the most likely cause?

GraphQL

app.use('/graphql', graphqlHTTP({
  schema: mySchema,
  graphiql: true,
  context: ({ req }) => req.user
}));

app.use('/graphql', (req, res, next) => {
  req.user = { id: '123', name: 'Alice' };
  next();
});

A The authentication middleware is registered after the graphqlHTTP middleware, so it runs too late

B The context function is not returning the user object correctly

C The schema does not define a user type

D The middleware does not call next()

💡 Hint

Think about the order in which middleware functions are executed in Express.

Express executes middleware in the order they are registered. Since the authentication middleware is registered after the GraphQL middleware, the req.user is not set when the context function runs, resulting in undefined.

❓ optimization

expert

Optimizing middleware for performance

In a high-traffic GraphQL server, which middleware optimization will most effectively reduce latency?

A Cache authentication results in middleware to avoid repeated checks per request

B Move authentication checks into resolvers instead of middleware

C Remove all middleware and handle everything in resolvers

D Use synchronous middleware functions to simplify code

💡 Hint

Consider how caching can reduce repeated work in middleware.

Caching authentication results in middleware avoids repeated expensive checks for the same user during a request or across requests, reducing latency. Moving checks into resolvers or removing middleware increases complexity and latency. Synchronous middleware can block the event loop, hurting performance.