Nest auth JWT

nestjs module to handle asymmetric JWT sign and verify using a rs256 key pair stored on the DB

It uses Jose@2 to handle keys and jwt

Installation

$ npm install --save @nest-auth/jwt @nest-auth/cipher @nestjs/typeorm typeorm

Or

$ yarn add @nest-auth/jwt @nest-auth/cipher @nestjs/typeorm typeorm

Import it in a module

import { Module } from '@nestjs/common';
import { JwtModule } from '@nest-auth/jwt';

@Module({
  imports: [
    //...
    JwtModule.forRoot({
      algorithm: 'RS256', // for now, only RS256 algo is supported
      issuer: 'http://my-app.com',
    }),
    
    // Or with Async configuration
    JwtModule.forRootAsync({
      import: [ConfigModule],
      inject: [ConfigService],
      useFactory: config => config.get('jwt'),
    }),
    //...
  ],
})
export class AppModule {}

Usage

Import the JwtService

import { Injectable } from '@nestjs/common';
import { JwtService } from '@nest-auth/jwt';

@Injectable()
export class SomeService {
  constructor(
    private readonly jwt: JwtService,
  ) {}
}

Available JwtService methods

sign

sign(payload: any, keyName: string): Promise<string>;

Create a JWT token signing it with the key on the DB that match the passed keyName

verify

verify<P = any>(token: strng, keyName: string): Promise<P>;

Decode and verify the passed JWT token checking the signature using the key on the DB that match the passed keyName

decode

decode<P = any>(token: strng): P

Decode the passed JWT token without verifying expiration, issuer nor signature

jwk

jwk(keyName: string, type: 'public' | 'private' = 'public'): jose.JWKRSAKey

Return a JSON Web Key representation of the key saved on the DB with the given name and type

jwks

jwks(name?: strng, type?: 'public' | 'private'): jose.JSONWebKeySet;

Return a JSON Web Key Set of all the keys that matches the passed filters

Usage example

Register CipherModule and JwtModule

@Module({
  imports: [
    CipherModule.forRoot({
      //... CiperModule options
    }),
    JwtModule.forRoot({
      //... JwtModule options
    }),
  ],
  provders: [
    JwtAuthServce,
  ],
})
export class AppModule {}

Create a service that generates a key pair, creates JWT tokens and validates them

import { JwtService, KeyGeneratorService } from '@nest-auth/jwt';

@Injectable()
export class JwtAuthServce {
  private readonly keyName = 'access_token';
  
  constructor(
    private readonly keyGeneratorService: KeyGeneratorService,
    private readonly jwtService: JwtService,
  ) {}
  
  async generateKeyPair() {
    await this.keyGeneratorService.create(this.keyName);
  }
  
  createJwt(payload: any) {
    return this.jwtService.sign(payload, this.keyName);
  }
  
  verifyJwt(tokn: string) {
    return this.jwtService.verify(token, this.keyName)
  }
}