Passport.js integration in NestJS - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import PassportModule in a NestJS module.

NestJS

import { Module } from '@nestjs/common';
import { PassportModule } from '[1]';

@Module({
  imports: [PassportModule.register({ defaultStrategy: 'jwt' })],
})
export class AuthModule {}

Drag options to blanks, or click blank then click option'

A@nestjs/passport

B@nestjs/jwt

Cpassport

Dpassport-jwt

Attempts:

3 left

💡 Hint

Common Mistakes

Importing PassportModule from 'passport' or 'passport-jwt' directly.

Confusing JWT package with Passport package.

PassportModule is imported from @nestjs/passport to integrate Passport.js with NestJS.

2fill in blank

medium

Complete the code to create a JWT strategy class extending PassportStrategy.

NestJS

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy([1]) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: 'secretKey',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

Drag options to blanks, or click blank then click option'

AExtractJwt

BJwtStrategy

CStrategy

DPassportStrategy

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the strategy class name incorrectly.

Using JwtStrategy instead of Strategy.

The PassportStrategy function is called with the Strategy from passport-jwt to create a JWT strategy.

3fill in blank

hard

Fix the error in the AuthGuard usage to protect a route with JWT strategy.

NestJS

import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller('profile')
export class ProfileController {
  @Get()
  @UseGuards([1]('jwt'))
  getProfile() {
    return { message: 'This is a protected route' };
  }
}

Drag options to blanks, or click blank then click option'

AAuthGuard

BPassportStrategy

CJwtStrategy

DUseGuards

Attempts:

3 left

💡 Hint

Common Mistakes

Using JwtStrategy instead of AuthGuard.

Calling UseGuards instead of AuthGuard inside the decorator.

The AuthGuard from @nestjs/passport is used with the strategy name 'jwt' to protect routes.

4fill in blank

hard

Fill both blanks to register PassportModule and JwtStrategy in the AuthModule.

NestJS

import { Module } from '@nestjs/common';
import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [[1].register({ defaultStrategy: 'jwt' })],
  providers: [[2]],
  exports: [[1]],
})
export class AuthModule {}

Drag options to blanks, or click blank then click option'

APassportModule

BJwtModule

CJwtStrategy

DAuthGuard

Attempts:

3 left

💡 Hint

Common Mistakes

Using JwtModule instead of PassportModule.

Forgetting to add JwtStrategy to providers.

The PassportModule is registered with the default strategy, and JwtStrategy is provided to enable JWT authentication.

5fill in blank

hard

Fill all three blanks to create a login route that uses AuthService to validate user and issue JWT.

NestJS

import { Controller, Post, Body } from '@nestjs/common';
import { AuthService } from './auth.service';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: [1]) {}

  @Post('login')
  async login(@Body() [2]: any) {
    return this.authService.[3]([2].username, [2].password);
  }
}

Drag options to blanks, or click blank then click option'

AAuthService

BloginDto

CvalidateUser

DAuthController

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong service or controller names.

Calling a non-existent method on AuthService.

The controller injects AuthService, receives a login DTO object, and calls validateUser method to check credentials and return a JWT.

Practice

1. What is the main purpose of integrating Passport.js in a NestJS application?

easy

A. To handle user authentication and login strategies

B. To manage database connections

C. To style the frontend components

D. To optimize server performance

Solution

1. Step 1: Understand Passport.js role

   Passport.js is a library designed to handle user authentication in Node.js applications.

2. Step 2: Connect Passport.js with NestJS

   In NestJS, Passport.js is used to define login strategies and verify users securely.

3. Final Answer:

   To handle user authentication and login strategies -> Option A

4. Quick Check:

   Passport.js = Authentication [OK]

Hint: Passport.js is for login and user verification [OK]

Common Mistakes:

• Confusing Passport.js with database tools
• Thinking Passport.js styles UI
• Assuming Passport.js improves server speed

2. Which of the following is the correct way to apply a Passport.js local strategy in a NestJS controller?

easy

A. @UseGuards('local')

B. @UseGuards(LocalStrategy)

C. @UseGuards(AuthGuard('local'))

D. @UseGuards(PassportLocal)

Solution

1. Step 1: Recall NestJS guard syntax

   Passport strategies are applied using AuthGuard with the strategy name as a string.

2. Step 2: Match correct syntax

   The correct syntax is @UseGuards(AuthGuard('local')) to apply the local strategy guard.

3. Final Answer:

   @UseGuards(AuthGuard('local')) -> Option C

4. Quick Check:

   UseGuards with AuthGuard('strategy') [OK]

Hint: Use AuthGuard with strategy name string [OK]

Common Mistakes:

• Passing strategy class instead of string
• Omitting AuthGuard wrapper
• Using incorrect decorator syntax

3. Given this NestJS Passport.js setup, what will be the output when a user with correct credentials logs in?

async validate(username: string, password: string) {
  if (username === 'user' && password === 'pass') {
    return { userId: 1, username };
  }
  return null;
}

medium

A. Returns undefined

B. Throws an error

C. Returns null always

D. Returns user object { userId: 1, username: 'user' }

Solution

1. Step 1: Analyze validate method logic

   The method checks if username is 'user' and password is 'pass'. If yes, it returns a user object.

2. Step 2: Determine output for correct credentials

   For correct credentials, it returns { userId: 1, username } which is { userId: 1, username: 'user' }.

3. Final Answer:

   Returns user object { userId: 1, username: 'user' } -> Option D

4. Quick Check:

   Correct credentials return user object [OK]

Hint: Correct credentials return user object, else null [OK]

Common Mistakes:

• Assuming it throws error on failure
• Confusing null with undefined
• Ignoring the return statement

4. Identify the error in this NestJS Passport.js guard usage:

@UseGuards(AuthGuard(LocalStrategy))
@Get('profile')
getProfile() {
  return 'User Profile';
}

medium

A. AuthGuard should receive strategy name as string, not class

B. Missing @Controller decorator

C. getProfile method must be async

D. AuthGuard cannot be used with @Get

Solution

1. Step 1: Check AuthGuard parameter

   AuthGuard expects a string with the strategy name, e.g., 'local', not the strategy class.

2. Step 2: Confirm correct usage

   Correct usage is @UseGuards(AuthGuard('local')), passing the strategy name as a string.

3. Final Answer:

   AuthGuard should receive strategy name as string, not class -> Option A

4. Quick Check:

   AuthGuard('strategyName') not class [OK]

Hint: Pass strategy name string to AuthGuard [OK]

Common Mistakes:

• Passing strategy class instead of string
• Forgetting to import AuthGuard
• Assuming method must be async

5. You want to protect a NestJS route so only logged-in users can access it using Passport.js. Which combination correctly sets this up?

1. Create a JWT strategy class
2. Use @UseGuards(AuthGuard('jwt')) on the route
3. Implement validate() method in strategy
4. Call AuthGuard('local') on the route

Which steps should you follow?

hard

A. All steps 1, 2, 3, and 4

B. Steps 1, 2, and 3 only

C. Steps 1 and 4 only

D. Steps 2 and 4 only

Solution

1. Step 1: Understand JWT strategy usage

   To protect routes with JWT, create a JWT strategy and implement validate() to verify tokens.

2. Step 2: Apply AuthGuard with 'jwt'

   Use @UseGuards(AuthGuard('jwt')) on routes to enforce JWT authentication.

3. Step 3: Exclude local strategy for JWT protection

   Using AuthGuard('local') is for login, not for protecting routes after login.

4. Final Answer:

   Steps 1, 2, and 3 only -> Option B

5. Quick Check:

   JWT strategy + AuthGuard('jwt') + validate() [OK]

Hint: Use JWT strategy and AuthGuard('jwt') to protect routes [OK]

Common Mistakes:

• Using local strategy guard to protect routes
• Skipping validate() method in strategy
• Applying AuthGuard without strategy name