npm package: @nest-auth/jwt
Description: ### nestjs module to handle asymmetric JWT sign and verify using a rs256 key pair stored on the DB
Author: Davide Gheri
Latest version: 0.3.0


# 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](https://github.com/panva/jose/tree/v2.x) to handle keys and jwt

## Installation

```bash
$ npm install --save @nest-auth/jwt @nest-auth/cipher @nestjs/typeorm typeorm
```
Or
```bash
$ yarn add @nest-auth/jwt @nest-auth/cipher @nestjs/typeorm typeorm
```

#### Import it in a module

```typescript
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

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

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

### Available JwtService methods

#### sign

```typescript
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

```typescript
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

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

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

#### jwk

```typescript
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

```typescript
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

```typescript
@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

```typescript
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)
  }
}
```