Authentication

Authentication is an essential part of most applications. There are many different approaches and strategies to handle authentication. The approach taken for any project depends on its particular application requirements. This chapter presents several approaches to authentication that can be adapted to a variety of different requirements.

Passport is the most popular node.js authentication library, well-known by the community and successfully used in many production applications. It’s straightforward to integrate this library with a Nest application using the @nestjs/passport module. At a high level, Passport executes a series of steps to:

  • Authenticate a user by verifying their “credentials” (such as username/password, JSON Web Token (JWT), or identity token from an Identity Provider)
  • Manage authenticated state (by issuing a portable token, such as a JWT, or creating an Express session)
  • Attach information about the authenticated user to the Request object for further use in route handlers

Passport has a rich ecosystem of strategies that implement various authentication mechanisms. While simple in concept, the set of Passport strategies you can choose from is large and presents a lot of variety. Passport abstracts these varied steps into a standard pattern, and the @nestjs/passport module wraps and standardizes this pattern into familiar Nest constructs.

In this chapter, we’ll implement a complete end-to-end authentication solution for a RESTful API server using these powerful and flexible modules. You can use the concepts described here to implement any Passport strategy to customize your authentication scheme. You can follow the steps in this chapter to build this complete example. You can find a repository with a completed sample app here.

Authentication Requirements

Let’s flesh out our requirements. For this use case, clients will start by authenticating with a username and password. Once authenticated, the server will issue a JWT that can be sent as a bearer token in an authorization header on subsequent requests to prove authentication. We’ll also create a protected route that is accessible only to requests that contain a valid JWT.

We’ll start with the first requirement: authenticating a user. We’ll then extend that by issuing a JWT. Finally, we’ll create a protected route that checks for a valid JWT on the request.

First we need to install the required packages. Passport provides a strategy called passport-local that implements a username/password authentication mechanism, which suits our needs for this portion of our use case.

  1. $ npm install --save @nestjs/passport passport passport-local
  2. $ npm install --save-dev @types/passport-local

warning Notice For any Passport strategy you choose, you’ll always need the @nestjs/passport and passport packages. Then, you’ll need to install the strategy-specific package (e.g., passport-jwt or passport-local) that implements the particular authentication strategy you are building. In addition, you can also install the type definitions for any Passport strategy, as show above with @types/passport-local, which provides assistance while writing TypeScript code.

Implementing Passport strategies

We’re now ready to implement the authentication feature. We’ll start with an overview of the process used for any Passport strategy. It’s helpful to think of Passport as a mini framework in itself. The elegance of the framework is that it abstracts the authentication process into a few basic steps that you customize based on the strategy you’re implementing. It’s like a framework because you configure it by supplying customization parameters (as plain JSON objects) and custom code in the form of callback functions, which Passport calls at the appropriate time. The @nestjs/passport module wraps this framework in a Nest style package, making it easy to integrate into a Nest application. We’ll use @nestjs/passport below, but first let’s consider how vanilla Passport works.

In vanilla Passport, you configure a strategy by providing two things:

  1. A set of options that are specific to that strategy. For example, in a JWT strategy, you might provide a secret to sign tokens.
  2. A “verify callback”, which is where you tell Passport how to interact with your user store (where you manage user accounts). Here, you verify whether a user exists (and/or create a new user), and whether their credentials are valid. The Passport library expects this callback to return a full user if the validation succeeds, or a null if it fails (failure is defined as either the user is not found, or, in the case of passport-local, the password does not match).

With @nestjs/passport, you configure a Passport strategy by extending the PassportStrategy class. You pass the strategy options (item 1 above) by calling the super() method in your subclass, optionally passing in an options object. You provide the verify callback (item 2 above) by implementing a validate() method in your subclass.

We’ll start by generating an AuthModule and in it, an AuthService:

  1. $ nest g module auth
  2. $ nest g service auth

As we implement the AuthService, we’ll find it useful to encapsulate user operations in a UsersService, so let’s generate that module and service now:

  1. $ nest g module users
  2. $ nest g service users

Replace the default contents of these generated files as shown below. For our sample app, the UsersService simply maintains a hard-coded in-memory list of users, and a find method to retrieve one by username. In a real app, this is where you’d build your user model and persistence layer, using your library of choice (e.g., TypeORM, Sequelize, Mongoose, etc.).

  1. @@filename(users/users.service)
  2. import { Injectable } from '@nestjs/common';
  4. export type User = any;
  6. @Injectable()
  7. export class UsersService {
  8.   private readonly users: User[];
  10.   constructor() {
  11.     this.users = [
  12.       {
  13.         userId: 1,
  14.         username: 'john',
  15.         password: 'changeme',
  16.       },
  17.       {
  18.         userId: 2,
  19.         username: 'chris',
  20.         password: 'secret',
  21.       },
  22.       {
  23.         userId: 3,
  24.         username: 'maria',
  25.         password: 'guess',
  26.       },
  27.     ];
  28.   }
  30.   async findOne(username: string): Promise<User | undefined> {
  31.     return this.users.find(user => user.username === username);
  32.   }
  33. }
  34. @@switch
  35. import { Injectable } from '@nestjs/common';
  37. @Injectable()
  38. export class UsersService {
  39.   constructor() {
  40.     this.users = [
  41.       {
  42.         userId: 1,
  43.         username: 'john',
  44.         password: 'changeme',
  45.       },
  46.       {
  47.         userId: 2,
  48.         username: 'chris',
  49.         password: 'secret',
  50.       },
  51.       {
  52.         userId: 3,
  53.         username: 'maria',
  54.         password: 'guess',
  55.       },
  56.     ];
  57.   }
  59.   async findOne(username) {
  60.     return this.users.find(user => user.username === username);
  61.   }
  62. }

In the UsersModule, the only change needed is to add the UsersService to the exports array of the @Module decorator so that it is visible outside this module (we’ll soon use it in our AuthService).

  1. @@filename(users/users.module)
  2. import { Module } from '@nestjs/common';
  3. import { UsersService } from './users.service';
  5. @Module({
  6.   providers: [UsersService],
  7.   exports: [UsersService],
  8. })
  9. export class UsersModule {}
  10. @@switch
  11. import { Module } from '@nestjs/common';
  12. import { UsersService } from './users.service';
  14. @Module({
  15.   providers: [UsersService],
  16.   exports: [UsersService],
  17. })
  18. export class UsersModule {}

Our AuthService has the job of retrieving a user and verifying the password. We create a validateUser() method for this purpose. In the code below, we use a convenient ES6 spread operator to strip the password property from the user object before returning it. We’ll be calling into the validateUser() method from our Passport local strategy in a moment.

  1. @@filename(auth/auth.service)
  2. import { Injectable } from '@nestjs/common';
  3. import { UsersService } from '../users/users.service';
  5. @Injectable()
  6. export class AuthService {
  7.   constructor(private readonly usersService: UsersService) {}
  9.   async validateUser(username: string, pass: string): Promise<any> {
  10.     const user = await this.usersService.findOne(username);
  11.     if (user && user.password === pass) {
  12.       const { password, ...result } = user;
  13.       return result;
  14.     }
  15.     return null;
  16.   }
  17. }
  18. @@switch
  19. import { Injectable, Dependencies } from '@nestjs/common';
  20. import { UsersService } from '../users/users.service';
  22. @Injectable()
  23. @Dependencies(UsersService)
  24. export class AuthService {
  25.   constructor(usersService) {
  26.     this.usersService = usersService;
  27.   }
  29.   async validateUser(username, pass) {
  30.     const user = await this.usersService.findOne(username);
  31.     if (user && user.password === pass) {
  32.       const { password, ...result } = user;
  33.       return result;
  34.     }
  35.     return null;
  36.   }
  37. }

Warning Warning Of course in a real application, you wouldn’t store a password in plain text. You’d instead use a library like bcrypt, with a salted one-way hash algorithm. With that approach, you’d only store hashed passwords, and then compare the stored password to a hashed version of the incoming password, thus never storing or exposing user passwords in plain text. To keep our sample app simple, we violate that absolute mandate and use plain text. Don’t do this in your real app!

Now, we update our AuthModule to import the UsersModule.

  1. @@filename(auth/auth.module)
  2. import { Module } from '@nestjs/common';
  3. import { AuthService } from './auth.service';
  4. import { UsersModule } from '../users/users.module';
  6. @Module({
  7.   imports: [UsersModule],
  8.   providers: [AuthService],
  9. })
  10. export class AuthModule {}
  11. @@switch
  12. import { Module } from '@nestjs/common';
  13. import { AuthService } from './auth.service';
  14. import { UsersModule } from '../users/users.module';
  16. @Module({
  17.   imports: [UsersModule],
  18.   providers: [AuthService],
  19. })
  20. export class AuthModule {}

Implementing Passport local

Now we can implement our Passport local authentication strategy. Create a file called local.strategy.ts in the auth folder, and add the following code:

  1. @@filename(auth/local.strategy)
  2. import { Strategy } from 'passport-local';
  3. import { PassportStrategy } from '@nestjs/passport';
  4. import { Injectable, UnauthorizedException } from '@nestjs/common';
  5. import { AuthService } from './auth.service';
  7. @Injectable()
  8. export class LocalStrategy extends PassportStrategy(Strategy) {
  9.   constructor(private readonly authService: AuthService) {
  10.     super();
  11.   }
  13.   async validate(username: string, password: string): Promise<any> {
  14.     const user = await this.authService.validateUser(username, password);
  15.     if (!user) {
  16.       throw new UnauthorizedException();
  17.     }
  18.     return user;
  19.   }
  20. }
  21. @@switch
  22. import { Strategy } from 'passport-local';
  23. import { PassportStrategy } from '@nestjs/passport';
  24. import { Injectable, UnauthorizedException, Dependencies } from '@nestjs/common';
  25. import { AuthService } from './auth.service';
  27. @Injectable()
  28. @Dependencies(AuthService)
  29. export class LocalStrategy extends PassportStrategy(Strategy) {
  30.   constructor(authService) {
  31.     this.authService = authService
  32.     super();
  33.   }
  35.   async validate(username, password) {
  36.     const user = await this.authService.validateUser(username, password);
  37.     if (!user) {
  38.       throw new UnauthorizedException();
  39.     }
  40.     return user;
  41.   }
  42. }

We’ve followed the recipe described earlier for all Passport strategies. In our use case with passport-local, there are no configuration options, so our constructor simply calls super(), without an options object.

We’ve also implemented the validate() method. For each strategy, Passport will call the verify function (implemented with the validate() method in @nestjs/passport) using an appropriate strategy-specific set of parameters. For the local-strategy, Passport expects a validate() method with the following signature: validate(username: string, password:string): any.

Most of the validation work is done in our AuthService (with the help of our UserService), so this method is quite straightforward. The validate() method for any Passport strategy will follow a similar pattern, varying only in the details of how credentials are represented. If a user is found and the credentials are valid, the user is returned so Passport can complete its tasks (e.g., creating the user property on the Request object), and the request handling pipeline can continue. If it’s not found, we throw an exception and let our exceptions layer handle it.

Typically, the only significant difference in the validate() method for each strategy is how you determine if a user exists and is valid. For example, in a JWT strategy, depending on requirements, we may evaluate whether the userId carried in the decoded token matches a record in our user database, or matches a list of revoked tokens. Hence, this pattern of sub-classing and implementing strategy-specific validation is consistent, elegant and extensible.

We need to configure our AuthModule to use the Passport features we just defined. Update auth.module.ts to look like this:

  1. @@filename(auth/auth.module)
  2. import { Module } from '@nestjs/common';
  3. import { AuthService } from './auth.service';
  4. import { UsersModule } from '../users/users.module';
  5. import { PassportModule } from '@nestjs/passport';
  6. import { LocalStrategy } from './local.strategy';
  8. @Module({
  9.   imports: [UsersModule, PassportModule],
  10.   providers: [AuthService, LocalStrategy],
  11. })
  12. export class AuthModule {}
  13. @@switch
  14. import { Module } from '@nestjs/common';
  15. import { AuthService } from './auth.service';
  16. import { UsersModule } from '../users/users.module';
  17. import { PassportModule } from '@nestjs/passport';
  18. import { LocalStrategy } from './local.strategy';
  20. @Module({
  21.   imports: [UsersModule, PassportModule],
  22.   providers: [AuthService, LocalStrategy],
  23. })
  24. export class AuthModule {}

Built-in Passport Guards

The Guards chapter describes the primary function of Guards: to determine whether a request will be handled by the route handler or not. That remains true, and we’ll use that standard capability soon. However, in the context of using the @nestjs/passport module, we will also introduce a slight new wrinkle that may at first be confusing, so let’s discuss that now. Consider that your app can exist in two states, from an authentication perspective:

  1. the user/client is not logged in (is not authenticated)
  2. the user/client is logged in (is authenticated)

In the first case (user is not logged in), we need to perform two distinct functions:

  • Restrict the routes an unauthenticated user can access (i.e., deny access to restricted routes). We’ll use Guards in their familiar capacity to handle this function, by placing a Guard on the protected routes. As you may anticipate, we’ll be checking for the presence of a valid JWT in this Guard, so we’ll work on this Guard later, once we are successfully issuing JWTs.

  • Initiate the authentication step itself when a previously unauthenticated user attempts to login. This is the step where we’ll issue a JWT to a valid user. Thinking about this for a moment, we know we’ll need to POST username/password credentials to initiate authentication, so we’ll set up a POST /auth/login route to handle that. This raises the question: how exactly do we invoke the passport-local strategy in that route?

The answer is straightforward: by using another, slightly different type of Guard. The @nestjs/passport module provides us with a built-in Guard that does this for us. This Guard invokes the Passport strategy and kicks off the steps described above (retrieving credentials, running the verify function, creating the user property, etc).

The second case enumerated above (logged in user) simply relies on the standard type of Guard we already discussed to enable access to protected routes for logged in users.

Login route

With the strategy in place, we can now implement a bare-bones /auth/login route, and apply the built-in Guard to initiate the passport-local flow.

Open the app.controller.ts file and replace its contents with the following:

  1. @@filename(app.controller)
  2. import { Controller, Request, Post, UseGuards } from '@nestjs/common';
  3. import { AuthGuard } from '@nestjs/passport';
  5. @Controller()
  6. export class AppController {
  7.   @UseGuards(AuthGuard('local'))
  8.   @Post('auth/login')
  9.   async login(@Request() req) {
  10.     return req.user;
  11.   }
  12. }
  13. @@switch
  14. import { Controller, Bind, Request, Post, UseGuards } from '@nestjs/common';
  15. import { AuthGuard } from '@nestjs/passport';
  17. @Controller()
  18. export class AppController {
  19.   @UseGuards(AuthGuard('local'))
  20.   @Post('auth/login')
  21.   @Bind(Req())
  22.   async login(req) {
  23.     return req.user;
  24.   }
  25. }

With @UseGuards(AuthGuard('local')) we are using an AuthGuard that @nestjs/passport automatically provisioned for us when we extended the passport-local strategy. Let’s break that down. Our Passport local strategy has a default name of 'local'. We reference that name in the @UseGuards() decorator to associate it with code supplied by the passport-local package. This is used to disambiguate which strategy to invoke in case we have multiple Passport strategies in our app (each of which may provision a strategy-specific AuthGuard). While we only have one such strategy so far, we’ll shortly add a second, so this is needed for disambiguation.

In order to test our route we’ll have our /auth/login route simply return the user for now. This also lets us demonstrate another Passport feature: Passport automatically creates a user object, based on the value we return from the validate() method, and assigns it to the Request object as req.user. Later, we’ll replace this with code to create and return a JWT instead.

Since these are API routes, we’ll test them using the commonly available cURL library. You can test with any of the user objects hard-coded in the UsersService.

  1. $ # POST to /auth/login
  2. $ curl -X POST http://localhost:3000/auth/login -d '{"username": "john", "password": "changeme"}' -H "Content-Type: application/json"
  3. $ # result -> {"userId":1,"username":"john"}

JWT functionality

We’re ready to move on to the JWT portion of our auth system. Let’s review and refine our requirements:

  • Allow users to authenticate with username/password, returning a JWT for use in subsequent calls to protected API endpoints. We’re well on our way to meeting this requirement. To complete it, we’ll need to write the code that issues a JWT.
  • Create API routes which are protected based on the presence of a valid JWT as a bearer token

We’ll need to install a couple more packages to support our JWT requirements:

  1. $ npm install @nestjs/jwt passport-jwt
  2. $ npm install @types/passport-jwt --save-dev

The @nest/jwt package (see more here) is a utility package that helps with JWT manipulation. The passport-jwt package is the Passport package that implements the JWT strategy and @types/passport-jwt provides the TypeScript type definitions.

Let’s take a closer look at how a POST /auth/login request is handled. We’ve decorated the route using the built-in AuthGuard provided by the passport-local strategy. This means that:

  1. The route handler will only be invoked if the user has been validated
  2. The req parameter will contain a user property (populated by Passport during the passport-local authentication flow)

With this in mind, we can now finally generate a real JWT, and return it in this route. To keep our services cleanly modularized, we’ll handle generating the JWT in the authService. Open the auth.service.ts file in the auth folder, and add the login() method, and import the JwtService as shown:

  1. @@filename(auth/auth.service)
  2. import { Injectable } from '@nestjs/common';
  3. import { UsersService } from '../users/users.service';
  4. import { JwtService } from '@nestjs/jwt';
  6. @Injectable()
  7. export class AuthService {
  8.   constructor(
  9.     private readonly usersService: UsersService,
  10.     private readonly jwtService: JwtService
  11.   ) {}
  13.   async validateUser(username: string, pass: string): Promise<any> {
  14.     const user = await this.usersService.findOne(username);
  15.     if (user && user.password === pass) {
  16.       const { password, ...result } = user;
  17.       return result;
  18.     }
  19.     return null;
  20.   }
  22.   async login(user: any) {
  23.     const payload = { username: user.username, sub: user.userId };
  24.     return {
  25.       access_token: this.jwtService.sign(payload),
  26.     };
  27.   }
  28. }
  30. @@switch
  31. import { Injectable, Dependencies } from '@nestjs/common';
  32. import { UsersService } from '../users/users.service';
  33. import { JwtService } from '@nestjs/jwt';
  35. @Dependencies(UsersService, JwtService)
  36. @Injectable()
  37. export class AuthService {
  38.   constructor(usersService, jwtService)
  39.   ) {
  40.     this.usersService = usersService;
  41.     this.jwtService = jwtService;
  42.   }
  44.   async validateUser(username, pass) {
  45.     const user = await this.usersService.findOne(username);
  46.     if (user && user.password === pass) {
  47.       const { password, ...result } = user;
  48.       return result;
  49.     }
  50.     return null;
  51.   }
  53.   async login(user) {
  54.     const payload = { username: user.username, sub: user.userId };
  55.     return {
  56.       access_token: this.jwtService.sign(payload),
  57.     };
  58.   }
  59. }

We’re using the @nestjs/jwt library, which supplies a sign() function to generate our JWT from a subset of the user object properties, which we then return as a simple object with a single access_token property. Note: we choose a property name of sub to hold our userId value to be consistent with JWT standards. Don’t forget to inject the JwtService provider into the AuthService.

We now need to update the AuthModule to import the new dependencies and configure the JwtModule.

First, create constants.ts in the auth folder, and add the following code:

  1. @@filename(auth/constants)
  2. export const jwtConstants = {
  3.   secret: 'secretKey',
  4. };
  5. @@switch
  6. export const jwtConstants = {
  7.   secret: 'secretKey',
  8. };

We’ll use this to share our key between the JWT signing and verifying steps.

Warning Warning Do not expose this key publicly. We have done so here to make it clear what the code is doing, but in a production system you must protect this key using appropriate measures such as a secrets vault, environment variable, or configuration service.

Now, open auth.module.ts in the auth folder and update it to look like this:

  1. @@filename(auth/auth.module)
  2. import { Module } from '@nestjs/common';
  3. import { AuthService } from './auth.service';
  4. import { LocalStrategy } from './local.strategy';
  5. import { UsersModule } from '../users/users.module';
  6. import { PassportModule } from '@nestjs/passport';
  7. import { JwtModule } from '@nestjs/jwt';
  8. import { jwtConstants } from './constants';
  10. @Module({
  11.   imports: [
  12.     UsersModule,
  13.     PassportModule,
  14.     JwtModule.register({
  15.       secret: jwtConstants.secret,
  16.       signOptions: { expiresIn: '60s' },
  17.     }),
  18.   ],
  19.   providers: [AuthService, LocalStrategy],
  20.   exports: [AuthService],
  21. })
  22. export class AuthModule {}
  23. @@switch
  24. import { Module } from '@nestjs/common';
  25. import { AuthService } from './auth.service';
  26. import { LocalStrategy } from './local.strategy';
  27. import { UsersModule } from '../users/users.module';
  28. import { PassportModule } from '@nestjs/passport';
  29. import { JwtModule } from '@nestjs/jwt';
  30. import { jwtConstants } from './constants';
  32. @Module({
  33.   imports: [
  34.     UsersModule,
  35.     PassportModule,
  36.     JwtModule.register({
  37.       secret: jwtConstants.secret,
  38.       signOptions: { expiresIn: '60s' },
  39.     }),
  40.   ],
  41.   providers: [AuthService, LocalStrategy],
  42.   exports: [AuthService],
  43. })
  44. export class AuthModule {}

We configure the JwtModule using register(), passing in a configuration object. See here for more on the Nest JwtModule and here for more details on the available configuration options.

Now we can update the /auth/login route to return a JWT.

  1. @@filename(app.controller)
  2. import { Controller, Request, Post, UseGuards } from '@nestjs/common';
  3. import { AuthGuard } from '@nestjs/passport';
  4. import { AuthService } from './auth/auth.service';
  6. @Controller()
  7. export class AppController {
  8.   constructor(private readonly authService: AuthService) {}
  10.   @UseGuards(AuthGuard('local'))
  11.   @Post('auth/login')
  12.   async login(@Request() req) {
  13.     return this.authService.login(req.user);
  14.   }
  15. }
  16. @@switch
  17. import { Controller, Bind, Request, Post, UseGuards } from '@nestjs/common';
  18. import { AuthGuard } from '@nestjs/passport';
  19. import { AuthService } from './auth/auth.service';
  21. @Controller()
  22. export class AppController {
  23.   constructor(private readonly authService: AuthService) {}
  25.   @UseGuards(AuthGuard('local'))
  26.   @Post('auth/login')
  27.   @Bind(Req())
  28.   async login(req) {
  29.     return this.authService.login(req.user);
  30.   }
  31. }

Let’s go ahead and test our routes using cURL again. You can test with any of the user objects hard-coded in the UsersService.

  1. $ # POST to /auth/login
  2. $ curl -X POST http://localhost:3000/auth/login -d '{"username": "john", "password": "changeme"}' -H "Content-Type: application/json"
  3. $ # result -> {"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."}
  4. $ # Note: above JWT truncated

Implementing Passport JWT

We can now address our final requirement: protecting endpoints by requiring a valid JWT be present on the request. Passport can help us here too. It provides the passport-jwt strategy for securing RESTful endpoints with JSON Web Tokens. Start by creating a file called jwt.strategy.ts in the auth folder, and add the following code:

  1. @@filename(auth/jwt.strategy)
  2. import { ExtractJwt, Strategy } from 'passport-jwt';
  3. import { PassportStrategy } from '@nestjs/passport';
  4. import { Injectable } from '@nestjs/common';
  5. import { jwtConstants } from './constants';
  7. @Injectable()
  8. export class JwtStrategy extends PassportStrategy(Strategy) {
  9.   constructor() {
  10.     super({
  11.       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
  12.       ignoreExpiration: false,
  13.       secretOrKey: jwtConstants.secret,
  14.     });
  15.   }
  17.   async validate(payload: any) {
  18.     return { userId: payload.sub, username: payload.username };
  19.   }
  20. }
  21. @@switch
  22. import { ExtractJwt, Strategy } from 'passport-jwt';
  23. import { PassportStrategy } from '@nestjs/passport';
  24. import { Injectable } from '@nestjs/common';
  25. import { jwtConstants } from './constants';
  27. @Injectable()
  28. export class JwtStrategy extends PassportStrategy(Strategy) {
  29.   constructor() {
  30.     super({
  31.       jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
  32.       ignoreExpiration: false,
  33.       secretOrKey: jwtConstants.secret,
  34.     });
  35.   }
  37.   async validate(payload) {
  38.     return { userId: payload.sub, username: payload.username };
  39.   }
  40. }

With our JwtStrategy, we’ve followed the same recipe described earlier for all Passport strategies. This strategy requires some initialization, so we do that by passing in an options object in the super() call. You can read more about the available options here. In our case, these options are:

  • jwtFromRequest: supplies the method by which the JWT will be extracted from the Request. We will use the standard approach of supplying a bearer token in the Authorization header of our API requests. Other options are described here.
  • ignoreExpiration: just to be explicit, we choose the default false setting, which delegates the responsibility of ensuring that a JWT has not expired to the Passport module. This means that if our route is supplied with an expired JWT, the request will be denied and a 401 Unauthorized response sent. Passport conveniently handles this automatically for us.
  • secretOrKey: we are using the expedient option of supplying a symmetric secret for signing the token. Other options, such as a PEM-encoded public key, may be more appropriate for production apps (see here for more information). In any case, as cautioned earlier, do not expose this secret publicly.

The validate() method deserves some discussion. For the jwt-strategy, Passport first verifies the JWT’s signature and decodes the JSON. It then invokes our validate() method passing the decoded JSON as its single parameter. Based on the way JWT signing works, we’re guaranteed that we’re receiving a valid token that we have previously signed and issued to a valid user.

As a result of all this, our response to the validate() callback is trivial: we simply return an object containing the userId and username properties. Recall again that Passport will build a user object based on the return value of our validate() method, and attach it as a property on the Request object.

It’s also worth pointing out that this approach leaves us room (‘hooks’ as it were) to inject other business logic into the process. For example, we could do a database lookup in our validate() method to extract more information about the user, resulting in a more enriched user object being available in our Request. This is also the place we may decide to do further token validation, such as looking up the userId in a list of revoked tokens, enabling us to perform token revocation. The model we’ve implemented here in our sample code is a fast, “stateless JWT” model, where each API call is immediately authorized based on the presence of a valid JWT, and a small bit of information about the requester (its userId and username) is available in our Request pipeline.

Add the new JwtStrategy as a provider in the AuthModule:

  1. @@filename(auth/auth.module)
  2. import { Module } from '@nestjs/common';
  3. import { AuthService } from './auth.service';
  4. import { LocalStrategy } from './local.strategy';
  5. import { JwtStrategy } from './jwt.strategy';
  6. import { UsersModule } from '../users/users.module';
  7. import { PassportModule } from '@nestjs/passport';
  8. import { JwtModule } from '@nestjs/jwt';
  9. import { jwtConstants } from './constants';
  11. @Module({
  12.   imports: [
  13.     UsersModule,
  14.     PassportModule,
  15.     JwtModule.register({
  16.       secret: jwtConstants.secret,
  17.       signOptions: { expiresIn: '60s' },
  18.     }),
  19.   ],
  20.   providers: [AuthService, LocalStrategy, JwtStrategy],
  21.   exports: [AuthService],
  22. })
  23. export class AuthModule {}
  24. @@switch
  25. import { Module } from '@nestjs/common';
  26. import { AuthService } from './auth.service';
  27. import { LocalStrategy } from './local.strategy';
  28. import { JwtStrategy } from './jwt.strategy';
  29. import { UsersModule } from '../users/users.module';
  30. import { PassportModule } from '@nestjs/passport';
  31. import { JwtModule } from '@nestjs/jwt';
  32. import { jwtConstants } from './constants';
  34. @Module({
  35.   imports: [
  36.     UsersModule,
  37.     PassportModule,
  38.     JwtModule.register({
  39.       secret: jwtConstants.secret,
  40.       signOptions: { expiresIn: '60s' },
  41.     }),
  42.   ],
  43.   providers: [AuthService, LocalStrategy, JwtStrategy],
  44.   exports: [AuthService],
  45. })
  46. export class AuthModule {}

By importing the same secret used when we signed the JWT, we ensure that the verify phase performed by Passport, and the sign phase performed in our AuthService, use a common secret.

Implement protected route and JWT strategy guards

We can now implement our protected route and its associated Guard.

Open the app.controller.ts file and update it as shown below:

  1. @@filename(app.controller)
  2. import { Controller, Get, Request, Post, UseGuards } from '@nestjs/common';
  3. import { AuthGuard } from '@nestjs/passport';
  4. import { AuthService } from './auth/auth.service';
  6. @Controller()
  7. export class AppController {
  8.   constructor(private readonly authService: AuthService) {}
  10.   @UseGuards(AuthGuard('local'))
  11.   @Post('auth/login')
  12.   async login(@Request() req) {
  13.     return this.authService.login(req.user);
  14.   }
  16.   @UseGuards(AuthGuard('jwt'))
  17.   @Get('profile')
  18.   getProfile(@Request() req) {
  19.     return req.user;
  20.   }
  21. }
  22. @@switch
  23. import { Controller, Bind, Get, Request, Post, UseGuards } from '@nestjs/common';
  24. import { AuthGuard } from '@nestjs/passport';
  25. import { AuthService } from './auth/auth.service';
  27. @Controller()
  28. export class AppController {
  29.   constructor(private readonly authService: AuthService) {}
  31.   @UseGuards(AuthGuard('local'))
  32.   @Post('auth/login')
  33.   @Bind(Req())
  34.   async login(req) {
  35.     return this.authService.login(req.user);
  36.   }
  38.   @UseGuards(AuthGuard('jwt'))
  39.   @Get('profile')
  40.   @Bind(Req())
  41.   getProfile(req) {
  42.     return req.user;
  43.   }
  44. }

Once again, we’re applying the AuthGuard that the @nestjs/passport module has automatically provisioned for us when we configured the passport-jwt module. This Guard is referenced by its default name, jwt. When our GET /profile route is hit, the Guard will automatically invoke our passport-jwt custom configured logic, validating the JWT, and assigning the user property to the Request object.

Ensure the app is running, and test the routes using cURL.

  1. $ # GET /profile
  2. $ curl http://localhost:3000/profile
  3. $ # result -> {"statusCode":401,"error":"Unauthorized"}
  5. $ # POST /auth/login
  6. $ curl -X POST http://localhost:3000/auth/login -d '{"username": "john", "password": "changeme"}' -H "Content-Type: application/json"
  7. $ # result -> {"access_token":"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2Vybm... }
  9. $ # GET /profile using access_token returned from previous step as bearer code
  10. $ curl http://localhost:3000/profile -H "Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2Vybm..."
  11. $ # result -> {"userId":1,"username":"john"}

Note that in the AuthModule, we configured the JWT to have an expiration of 60 seconds. This is probably too short an expiration, and dealing with the details of token expiration and refresh is beyond the scope of this article. However, we chose that to demonstrate an important quality of JWTs and the passport-jwt strategy. If you wait 60 seconds after authenticating before attempting a GET /profile request, you’ll receive a 401 Unauthorized response. This is because Passport automatically checks the JWT for its expiration time, saving you the trouble of doing so in your application.

We’ve now completed our JWT authentication implementation. JavaScript clients (such as Angular/React/Vue), and other JavaScript apps, can now authenticate and communicate securely with our API Server. You can find a complete version of the code in this chapter here.

Default strategy

In our AppController, we pass the name of the strategy in the @AuthGuard() decorator. We need to do this because we’ve introduced two Passport strategies (passport-local and passport-jwt), both of which supply implementations of various Passport components. Passing the name disambiguates which implementation we’re linking to. When multiple strategies are included in an application, we can declare a default strategy so that we no longer have to pass the name in the @AuthGuard decorator if using that default strategy. Here’s how to register a default strategy when importing the PassportModule. This code would go in the AuthModule:

  1. import { Module } from '@nestjs/common';
  2. import { AuthService } from './auth.service';
  3. import { LocalStrategy } from './local.strategy';
  4. import { UsersModule } from '../users/users.module';
  5. import { PassportModule } from '@nestjs/passport';
  6. import { JwtModule } from '@nestjs/jwt';
  7. import { jwtConstants } from './constants';
  8. import { JwtStrategy } from './jwt.strategy';
  10. @Module({
  11.   imports: [
  12.     PassportModule.register({ defaultStrategy: 'jwt' }),
  13.     JwtModule.register({
  14.       secret: jwtConstants.secret,
  15.       signOptions: { expiresIn: '60s' },
  16.     }),
  17.     UsersModule
  18.   ],
  19.   providers: [AuthService, LocalStrategy, JwtStrategy],
  20.   exports: [AuthService],
  21. })
  22. export class AuthModule {}

Customize Passport

Any standard Passport customization options can be passed the same way, using the register() method. The available options depend on the strategy being implemented. For example:

  1. PassportModule.register({ session: true });

You can also pass strategies an options object in their constructors to configure them.For the local strategy you can pass e.g.:

  1. constructor(private readonly authService: AuthService) {
  2.   super({
  3.     usernameField: 'email',
  4.     passwordField: 'password',
  5.   });
  6. }

Take a look at the official Passport Website for property names.

Named strategies

When implementing a strategy, you can provide a name for it by passing a second argument to the PassportStrategy function. If you don’t do this, each strategy will have a default name (e.g., ‘jwt’ for jwt-strategy):

  1. export class JwtStrategy extends PassportStrategy(Strategy, 'myjwt')

Then, you refer to this via a decorator like @AuthGuard('myjwt').

GraphQL

In order to use an AuthGuard with GraphQL, extend the built-in AuthGuard class and override the getRequest() method.

  1. @Injectable()
  2. export class GqlAuthGuard extends AuthGuard('jwt') {
  3.   getRequest(context: ExecutionContext) {
  4.     const ctx = GqlExecutionContext.create(context);
  5.     return ctx.getContext().req;
  6.   }
  7. }

To use the above construct, be sure to pass the request (req) object as part of the context value in the GraphQL Module settings:

  1. GraphQLModule.forRoot({
  2.   context: ({ req }) => ({ req }),
  3. });

To get the current authenticated user in your graphql resolver, you can define a User decorator:

  1. import { createParamDecorator } from '@nestjs/common';
  3. export const CurrentUser = createParamDecorator(
  4.   (data, [root, args, ctx, info]) => ctx.req.user,
  5. );

To use above decorator in your resolver, be sure to include it as a parameter of your query or mutation:

  1. @Query(returns => User)
  2. @UseGuards(GqlAuthGuard)
  3. whoAmI(@CurrentUser() user: User) {
  4.   return this.userService.findById(user.id);
  5. }