Server middleware in GraphQL - Time & Space Complexity

Time Complexity: Server middleware

O(n)

Understanding Time Complexity

When using server middleware in GraphQL, it is important to understand how the time it takes to handle requests grows as more requests or data come in.

We want to know how the processing time changes when middleware runs before the main query logic.

Scenario Under Consideration

Analyze the time complexity of the following GraphQL middleware setup.

const middleware = async (resolve, root, args, context, info) => {
  // Example: logging each request
  console.log('Request received');
  const result = await resolve(root, args, context, info);
  return result;
};

const resolvers = {
  Query: {
    user: middleware(async (root, args, context, info) => {
      // fetch user by id
      return getUserById(args.id);
    })
  }
};
    

This code adds middleware that runs before the main resolver to log requests, then calls the resolver to fetch data.

Identify Repeating Operations

Look for repeated actions that affect time.

• Primary operation: Middleware runs once per GraphQL query request.
• How many times: Once for each query execution, before the resolver runs.

How Execution Grows With Input

As the number of queries increases, the middleware runs once per query.

Input Size (number of queries)	Approx. Operations
10	10 middleware calls
100	100 middleware calls
1000	1000 middleware calls

Pattern observation: The total work grows directly with the number of queries, adding a small fixed cost each time.

Final Time Complexity

Time Complexity: O(n)

This means the middleware adds a small, constant amount of work for each query, so total time grows linearly with the number of queries.

Common Mistake

[X] Wrong: "Middleware runs once and handles all queries together, so time does not grow with more queries."

[OK] Correct: Middleware runs separately for each query request, so more queries mean more middleware executions.

Interview Connect

Understanding how middleware affects time helps you design efficient GraphQL servers and shows you can think about performance in real applications.

Self-Check

What if the middleware made a database call before each resolver? How would that change the time complexity?