Why guards control access in NestJS - Visual Breakdown

Concept Flow - Why guards control access

Request Received

↓

Guard Checks Conditions

↓

Allow

↓

Controller Executes

When a request comes in, the guard checks if access is allowed. If yes, the controller runs. If no, access is denied.

Execution Sample

NestJS

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

This guard checks if the user is an admin before allowing access.

Execution Table

Step	Action	Input	Condition Checked	Result	Next Step
1	Receive request	{ user: { isAdmin: true } }	N/A	N/A	Check guard
2	Guard reads user	{ isAdmin: true }	user.isAdmin === true	True	Allow access
3	Controller runs	N/A	N/A	Request processed	Send response
4	Receive request	{ user: { isAdmin: false } }	N/A	N/A	Check guard
5	Guard reads user	{ isAdmin: false }	user.isAdmin === true	False	Deny access
6	Send error	N/A	N/A	403 Forbidden	End

💡 Execution stops when guard denies access or controller finishes processing.

Variable Tracker

Variable	Start	After Step 2	After Step 5	Final
request.user.isAdmin	undefined	true	false	N/A
canActivate result	undefined	true	false	N/A

Key Moments - 2 Insights

Why does the guard block access when user.isAdmin is false?

Because in the execution_table at step 5, the condition user.isAdmin === true evaluates to false, so the guard returns false and denies access.

What happens if the guard returns true?

As shown in execution_table step 2, if the guard returns true, the controller executes and processes the request.

Visual Quiz - 3 Questions

Look at the execution_table, what is the guard's result at step 2?

A False

B True

C Undefined

D Error

💡 Hint

Check the 'Result' column in execution_table row with Step 2.

At which step does the guard deny access?

A Step 5

B Step 1

C Step 3

D Step 6

💡 Hint

Look for where the condition user.isAdmin === true is false in execution_table.

If user.isAdmin was always true, what would change in the execution_table?

A The guard would throw an error.

B All requests would be denied.

C All requests would be allowed, no deny steps.

D The controller would never run.

💡 Hint

Refer to variable_tracker and see how canActivate result affects flow.

Concept Snapshot

Guards in NestJS check conditions before a controller runs.
They return true to allow access or false to deny it.
Guards control who can use routes.
They help protect resources by blocking unauthorized requests.
Use canActivate method to define guard logic.

Full Transcript

In NestJS, guards control access by checking conditions before a controller handles a request. When a request arrives, the guard's canActivate method runs. It looks at the request data, like user roles, and returns true or false. If true, the controller runs and processes the request. If false, the guard denies access and sends an error response. This way, guards protect routes from unauthorized users. For example, a guard can check if a user is an admin. If yes, access is allowed; if no, access is blocked. This flow ensures only allowed users reach the controller.

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