Accessing request in the validate of JWT strategy

The default definition for the JwtStrategy offers to pass the payload parameter to the validate function:

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

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: jwtConstants.secret,
    });
  }

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

There are sometimes cases where the validate fn should receive the request object. To have this possibility, specify the passReqToCallback to true:

    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      ignoreExpiration: false,
      secretOrKey: jwtConstants.secret,
      passReqToCallback: true // <-----
    });

In that way, the validate function will firstly receive request and secondly jwtPayload:

  async validate(request: Request, payload: any) {
    // do something with the request
    return { userId: payload.sub, username: payload.username };
  }

Creating a type that requires alternative fields

In order to create a type that should require one of the alternative fields be required, use the union with alternative. For instance, the following type requires a person to have either socialSecurityNumber or dateOfBirth present:

type Person = {
  name: string
} & (
  | { socialSecurityNumber: string }
  | { dateOfBirth: string}
)

The first part contains a standard set of fields:

type Person = {
  name: string
} 

that is combined with two alternative types using the union (&) and alternative (|) signs:

& (
  | { socialSecurityNumber: string}
  | { dateOfBirth: string}
)

Then these examples are valid:

const simon: Person = {
  name: 'simon',
  socialSecurityNumber: 'ssn'
}

const peter: Person = {
  name: 'peter',
  dateOfBirth: '01.01.1901'
}

const pete: Person = {
  name: 'peter',
  dateOfBirth: '01.01.1901',
  socialSecurityNumber: 'ssn'
}

But an object containing just name will generate an error:

const invalidPerson: Person = {
  name: 'peter',
}

Type '{ name: string; }' is not assignable to type 'Person'.
  Type '{ name: string; }' is not assignable to type '{ name: string; } & { dateOfBirth: string; }'.
    Property 'dateOfBirth' is missing in type '{ name: string; }' but required in type '{ dateOfBirth: string; }'.

Dynamically accessing static properties of an instance

Use Object.getPrototypeOf(<instance>).constructor.<static-property-name> to access static-property-name of instance. Example:

class Person {
  name = 'person'

  static names = ['simon', 'nomis']
}

class Dog {
  name = 'dog'

  static names = ['kajtek', 'maniek']
}

const person = new Person()
const dog = new Dog()

function displayNames(named: Person | Dog) {
  console.log(`${named.name} - names: ${Object.getPrototypeOf(named).constructor.names}`)
}

displayNames(person)
displayNames(dog)

Results in:

[LOG]: "person - names: simon,nomis" 
[LOG]: "dog - names: kajtek,maniek" 

Breaking change in NestJS mailer's API - pug templates

With this commit - ver. 1.6.0, it is required to specify leading characters: ./ in the template’s name. Otherwise, the mailer complains about the missing template:

Error: ENOENT: no such file or directory, open 'sendDocument.pug'
    at Object.openSync (fs.js:465:3)
    at Object.readFileSync (fs.js:368:35)
    at handleTemplateCache (/api/node_modules/pug/lib/index.js:245:37)
    at Object.exports.renderFile (/api/node_modules/pug/lib/index.js:458:10)
    at Object.exports.renderFile (/api/node_modules/pug/lib/index.js:448:21)

A sample correct name:

await this.mailer.sendMail({
  template: './sendDocument',
  // ...
})

Bull board for NestJS

Install packages

• bull-board
• express-basic-auth

Setup the board in the main file

In the main.ts file:

const app = await NestFactory.create(AppModule, {
  // ...
})

const aQueue = app.get<Queue>(
  `BullQueue_<queue_name>`
)

const { router: bullRouter } = createBullBoard([
  new BullAdapter(aQueue),
])

app.use(
  '/bull-board',
  expressBasicAuth({
    users: {
      user: 'password',
    },
    challenge: true,
  }),
  bullRouter
)

Bull board will be protected with basic HTTP authentication.

Impact of TYPEORM_CONNECTION on ormconfig in TypeOrm

When TypeOrm detects that either TYPEORM_CONNECTION or TYPEORM_URL env variables are set up, it will read the config from the env variables and ignore the one that is given by the ormconfig.js file:

// try to find connection options from any of available sources of configuration
if (PlatformTools.getEnvVariable("TYPEORM_CONNECTION") || PlatformTools.getEnvVariable("TYPEORM_URL")) {
   connectionOptions = await new ConnectionOptionsEnvReader().read();

From their docs:

Sometimes, you may want to use multiple configurations using different formats. When calling getConnectionOptions() or attempting to use createConnection() without the connection options, Typeorm will attempt to load the configurations, in this order:

• From the environment variables. Typeorm will attempt to load the .env file using dotEnv if it exists. If the environment variables TYPEORM_CONNECTION or TYPEORM_URL are set, Typeorm will use this method.
• From the ormconfig.env.
• From the other ormconfig.[format] files, in this order: [js, ts, json, yml, yaml, xml].

Tip for the future: to use the ormconfig.js file, do not set up the TYPEORM_CONNECTION and TYPEORM_URL env vars.

Resolving "Nest can't resolve dependencies of the X"

From time to time you can see the error:

Nest can’t resolve dependencies of the X. Please make sure that the “Y” property is available in the current context.

In case of services:

• Ensure the service is exposed in the module
• Ensure the module exposing the service is included in the module
• In tests: ensure the service is provided in the createTestingModule function
• Check for circular dependencies; if you think there is one, use forwardRef in the place where the service is injected: @Inject(forwardRef(() => UserService)) private readonly userService: UserService