Why guards control access in NestJS - Performance Evidence

Performance: Why guards control access

MEDIUM IMPACT

Guards affect the speed of request handling by controlling access before route handlers run, impacting server response time and user experience.

Controlling access to routes in a NestJS application

NestJS

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class FastGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Simple, fast check
    const request = context.switchToHttp().getRequest();
    return Boolean(request.headers['authorization']);
  }
}

The guard performs a quick check without blocking, allowing fast request processing.

📈 Performance GainNon-blocking, minimal CPU usage, improves INP by reducing request delay.

Controlling access to routes in a NestJS application

NestJS

import { Injectable, CanActivate, ExecutionContext } from '@nestjs/common';

@Injectable()
export class SlowGuard implements CanActivate {
  canActivate(context: ExecutionContext): boolean {
    // Simulate heavy synchronous processing
    for (let i = 0; i < 1e8; i++) {}
    return true;
  }
}

The guard performs heavy synchronous work blocking the event loop, delaying all requests.

📉 Performance CostBlocks event loop for 100+ ms per request, increasing INP and slowing response.

Performance Comparison

Pattern	CPU Usage	Event Loop Blocking	Response Delay	Verdict
Heavy synchronous guard logic	High	Yes, blocks event loop	High delay	[X] Bad
Lightweight guard with simple checks	Low	No	Minimal delay	[OK] Good

Rendering Pipeline

Guards run early in the request lifecycle before route handlers, affecting server response timing and user interaction speed.

→Request Handling

→Middleware Execution

⚠️ BottleneckHeavy synchronous logic in guards blocks the event loop, delaying response.

Core Web Vital Affected

INP

Guards affect the speed of request handling by controlling access before route handlers run, impacting server response time and user experience.

Optimization Tips

1Keep guard logic simple and non-blocking to avoid event loop delays.

2Avoid heavy synchronous computations inside guards.

3Use asynchronous checks if needed to maintain fast request handling.

Performance Quiz - 3 Questions

What is the main performance risk of a guard with heavy synchronous logic in NestJS?

A It increases bundle size significantly.

B It blocks the event loop, delaying all requests.

C It causes layout shifts in the browser.

D It improves server response time.

DevTools: Node.js Profiler or NestJS Debug Logs

How to check: Run the app with profiling enabled, make requests, and observe CPU usage and event loop delays in the profiler or logs.

What to look for: Look for long synchronous tasks in guard functions causing event loop blocking and increased response times.

Practice

1. What is the main purpose of guards in a NestJS application?

easy

A. To format the response data before sending it to the client

B. To control access by allowing or blocking requests based on conditions

C. To manage database connections and queries

D. To handle errors and exceptions globally

Solution

1. Step 1: Understand the role of guards

   Guards are designed to check conditions before a route handler runs, deciding if access should be granted.

2. Step 2: Compare with other responsibilities

   Formatting responses, managing database, and error handling are done by other parts of NestJS, not guards.

3. Final Answer:

   To control access by allowing or blocking requests based on conditions -> Option B

4. Quick Check:

   Guards control access = A [OK]

Hint: Guards decide if a request can proceed or not [OK]

Common Mistakes:

• Confusing guards with interceptors or filters
• Thinking guards handle data formatting
• Assuming guards manage database logic

2. Which of the following is the correct way to apply a guard to a controller method in NestJS?

easy

A. @UseGuards(AuthGuard) before the method declaration

B. @Guard(AuthGuard) inside the method body

C. UseGuards(AuthGuard) as a function call in the constructor

D. Apply guard logic directly inside the controller constructor

Solution

1. Step 1: Recall NestJS guard syntax

   Guards are applied using the @UseGuards() decorator placed before the method or class.

2. Step 2: Evaluate options

   Only @UseGuards(AuthGuard) before the method declaration uses the correct decorator syntax before the method. Others misuse syntax or placement.

3. Final Answer:

   @UseGuards(AuthGuard) before the method declaration -> Option A

4. Quick Check:

   @UseGuards decorator = A [OK]

Hint: Use @UseGuards decorator above methods or classes [OK]

Common Mistakes:

• Using @Guard instead of @UseGuards
• Calling UseGuards as a function inside constructor
• Placing guard logic inside constructor instead of decorator

3. Given this guard code snippet:

canActivate(context: ExecutionContext) {
  const request = context.switchToHttp().getRequest();
  return request.user && request.user.isAdmin;
}

What will happen if a user without isAdmin tries to access the guarded route?

medium

A. Access will be granted because the guard always returns true

B. The guard will ignore the user and allow access

C. An error will be thrown due to missing isAdmin property

D. Access will be denied because isAdmin is false or missing

Solution

1. Step 1: Analyze the guard condition

   The guard returns true only if request.user exists and request.user.isAdmin is truthy.

2. Step 2: Consider user without isAdmin

   If isAdmin is false or missing, the condition returns false, denying access.

3. Final Answer:

   Access will be denied because isAdmin is false or missing -> Option D

4. Quick Check:

   Guard returns false if not admin = B [OK]

Hint: Guard returns true only if user is admin [OK]

Common Mistakes:

• Assuming missing property causes error
• Thinking guard always returns true
• Ignoring the boolean check on isAdmin

4. Identify the error in this guard implementation:

canActivate(context: ExecutionContext) {
  const request = context.getRequest();
  if (!request.user) {
    throw new Error('User not found');
  }
  return true;
}

medium

A. Throwing an error inside a guard instead of returning false

B. Missing async keyword for canActivate method

C. Using context.getRequest() instead of context.switchToHttp().getRequest()

D. Returning true without checking user roles

Solution

1. Step 1: Check method usage for request

   While context.getRequest() is invalid, the main issue is guard behavior on failure.

2. Step 2: Understand guard error handling

   Guards should return false to deny access, not throw errors which cause server crashes.

3. Final Answer:

   Throwing an error inside a guard instead of returning false -> Option A

4. Quick Check:

   Guards return false, not throw errors [OK]

Hint: Return false to block access, don't throw errors in guards [OK]

Common Mistakes:

• Throwing errors instead of returning false
• Using incorrect context method for request
• Assuming async is required without async code

5. You want to restrict access to a route only to logged-in users with the role 'admin' or 'moderator'. Which guard logic correctly implements this?

hard

A. Return true if request.user does not exist

B. Return true if request.user exists and request.user.role === 'admin' && request.user.role === 'moderator'

C. Return true if request.user exists and request.user.role === 'admin' || request.user.role === 'moderator'

D. Return true if request.user exists and request.user.role !== 'admin' || request.user.role !== 'moderator'

Solution

1. Step 1: Understand role conditions

   The user must be logged in and have role 'admin' OR 'moderator' to access.

2. Step 2: Evaluate logical operators

   Return true if request.user exists and request.user.role === 'admin' || request.user.role === 'moderator' uses OR (||) correctly. Return true if request.user exists and request.user.role === 'admin' && request.user.role === 'moderator' uses AND (&&) which is impossible for one role. Return true if request.user exists and request.user.role !== 'admin' || request.user.role !== 'moderator' uses negations incorrectly. Return true if request.user does not exist allows access without user.

3. Final Answer:

   Return true if request.user exists and request.user.role === 'admin' || request.user.role === 'moderator' -> Option C

4. Quick Check:

   Use OR for multiple allowed roles = D [OK]

Hint: Use OR (||) to allow multiple roles [OK]

Common Mistakes:

• Using AND (&&) instead of OR (||) for roles
• Allowing access when user is missing
• Incorrect negation logic in conditions