Integración de Passport.js
Aprenda a integrar estrategias de Passport.js, como Local y JWT, para crear flujos de autenticación flexibles y sólidos.
Integración de Passport.js es una lección gratuita de Next.js 15 Fullstack (App Router + Server Actions) en CoddyKit. Esta es la lección 6 de 6. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Next.js 15 Fullstack (App Router + Server Actions), y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Next.js 15 Fullstack (App Router + Server Actions) incluye 6 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Meet Passport.js
Welcome to integrating Passport.js with NestJS! Passport is a popular authentication middleware for Node.js applications.
It provides a flexible and modular way to handle different authentication mechanisms, known as 'strategies'. NestJS has excellent integration with Passport, making it easy to secure your APIs.
Setting Up Passport.js
To get started, you'll need to install a few packages. We'll install the core Passport packages for NestJS and specific strategies for local (username/password) and JWT authentication.
@nestjs/passport: NestJS integrationpassport: Core Passport.js librarypassport-local: For username/password authenticationpassport-jwt: For JSON Web Token authentication
npm install @nestjs/passport passport passport-local passport-jwtPassport Strategy: Local
The Local Strategy is used for traditional username and password authentication. When a user tries to log in, Passport.js uses this strategy to verify their credentials.
You'll create a class that extends PassportStrategy(Strategy, 'local') and implement a validate method. This method receives the username and password from the request.
Local Strategy Logic
The validate method is the heart of any Passport strategy. It's where you define the logic to verify credentials (e.g., checking against a database). If validation succeeds, it returns the user object; otherwise, it returns null or throws an error.
Try running this simplified example of the validate logic:
class MockLocalStrategy {
async validate(username: string, password: string): Promise<any> {
// In a real app, you'd query a database here
if (username === 'testuser' && password === 'mypass') {
return { userId: 1, username: 'testuser' };
}
return null; // Or throw an error for invalid credentials
}
}
async function main() {
const strategy = new MockLocalStrategy();
const user = await strategy.validate('testuser', 'mypass');
if (user) {
console.log(`Auth successful for: ${user.username}`);
} else {
console.log('Auth failed: Invalid credentials');
}
}
main();Using Local Strategy with Guards
Once your LocalStrategy is defined and registered, you can protect routes using NestJS Guards. The AuthGuard('local') leverages your strategy to authenticate incoming requests.
If the user is authenticated, the user object returned by your validate method will be attached to the request (req.user).
@Post('login')
@UseGuards(AuthGuard('local'))
async login(@Request() req) {
return req.user;
}Passport Strategy: JWT
The JWT Strategy is used to validate JSON Web Tokens. Instead of username/password, it extracts the JWT from the request (usually from the Authorization header) and verifies its signature.
Your JwtStrategy also has a validate method, but it receives the decrypted JWT payload. You then use this payload to identify and return the user.
JWT Strategy Logic
For the JWT Strategy, the validate method receives the token's payload after Passport has already verified the token's signature. Your job here is usually to retrieve the user associated with that payload (e.g., from a database).
Here's a simplified example of the validate logic:
class MockJwtStrategy {
async validate(payload: any): Promise<any> {
// In a real app, you'd fetch user from DB based on payload.sub
if (payload && payload.sub === 101) {
return { userId: payload.sub, username: 'apiuser' };
}
return null; // User not found or invalid payload
}
}
async function main() {
const strategy = new MockJwtStrategy();
// Imagine this payload came from a verified JWT
const mockPayload = { sub: 101, username: 'apiuser', iat: 123, exp: 456 };
const user = await strategy.validate(mockPayload);
if (user) {
console.log(`JWT validation successful for: ${user.username}`);
} else {
console.log('JWT validation failed: User not found');
}
}
main();Using JWT Strategy with Guards
Similar to the local strategy, you use AuthGuard('jwt') to protect routes that require a valid JWT. This guard automatically extracts, validates, and decodes the token using your JwtStrategy.
If the token is valid, the user object returned by validate is attached to req.user.
@Get('profile')
@UseGuards(AuthGuard('jwt'))
getProfile(@Request() req) {
return req.user;
}Flexible Authentication Flows
Passport.js excels in its flexibility. You can use multiple strategies within a single application and even specify multiple strategies for a single route using AuthGuard(['jwt', 'local']).
This allows you to support various authentication methods, like social logins (OAuth strategies), API keys, or session-based auth, all managed by Passport's unified interface.
Check Your Understanding
Let's test your knowledge about Passport.js strategies.
Recap: Passport.js Integration
In this lesson, we explored how to integrate Passport.js into your NestJS applications. We covered:
- The core concept of Passport.js and its strategies.
- Implementing a Local Strategy for username/password authentication.
- Implementing a JWT Strategy for token-based authentication.
- Using AuthGuards to protect your API routes with these strategies.
Passport.js provides a powerful and flexible foundation for building robust authentication flows!
Aprende TypeScript con un tutor de IA — gratis
Escribe y ejecuta código real en tu navegador, obtén ayuda instantánea de un tutor de IA disponible 24/7 y continúa donde lo dejaste en la web o en la aplicación.
- Cursos
- 22
- Lecciones
- 88
Preguntas frecuentes
¿La lección «Integración de Passport.js» es gratis?
Sí — el texto completo de «Integración de Passport.js» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Next.js 15 Fullstack (App Router + Server Actions), actualiza a CoddyKit PRO. El curso de Next.js 15 Fullstack (App Router + Server Actions) incluye 6 lecciones en total.
¿Qué aprenderé en «Integración de Passport.js»?
Aprenda a integrar estrategias de Passport.js, como Local y JWT, para crear flujos de autenticación flexibles y sólidos. Practicas Next.js 15 Fullstack (App Router + Server Actions) con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Next.js 15 Fullstack (App Router + Server Actions)?
No se requiere experiencia previa. Next.js 15 Fullstack (App Router + Server Actions) en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 6 de 6.
¿Cuánto tiempo toma la lección «Integración de Passport.js»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Next.js 15 Fullstack (App Router + Server Actions)?
Sí. Cada lección de Next.js 15 Fullstack (App Router + Server Actions) incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Integración de NextAuth.js
- Implementación de estrategias JWT
- Protección de rutas y datos
- Guards y roles
- Estrategias de autenticación personalizadas
- Integración de Passport.js