Today I Learned

11 posts about #nodejs

Remove/change modifiers of an existing regexp

The following regexp has a couple of modifier:

const regexp = /my-project-id/gi
// -> /my-project-id/gi

to reuse the existing regexp and remove the modifier, create a new instance of the regexp with a blank modifier:

const regexp2 = new RegExp(regexp, '')
// -> /my-project-id/

You can also omit modifiers from existing ones specified in the regexp:

const regexp3 = new RegExp(regexp, regexp.flags.replace('g', ''))
// -> /my-project-id/i

Faster E2E tests & stable DB setup in NestJS

Link to earlier post on E2E tests in NestJS

The following setup allowed to cut down the duration of E2E tests by 2/3 (from 356s to 111s). The app uses TypeORM.

A single app instance for the whole E2E run.

File: test/utils/create-testing-module.ts

// Single app instance
let app: INestApplication

export async function createTestingModule() {
  const moduleBuilder = Test.createTestingModule({
    imports: [AppModule],
  })

  const module = await moduleBuilder.compile()

  app = module.createNestApplication(undefined, {
    logger: false,
  })

  await app.init()
}

export async function closeTestingModule() {
  await getConnection().dropDatabase()

  if (app) await app.close()
}

export function getTestingModule() {
  if (!app) throw 'No app was initialized!!!'

  return app
}

Functions to drop & clean up the DB:

File test/utils/clean-up-db.ts - a collection of functions to drop/clean up the DB:

const tableNames = [
  'contact',
  'user',
]

export async function cleanUpDb() {
  const connection = getConnection()

  for (const tableName of tableNames) {
    await connection.query(`DELETE FROM ${tableName};`)
  }
}

export async function dropTables() {
  const connection = await createConnection({
    type: 'mysql',
    username: process.env.TYPEORM_USERNAME,
    password: process.env.TYPEORM_PASSWORD,
    database: process.env.TYPEORM_DATABASE,
  })

  await connection.query('SET FOREIGN_KEY_CHECKS=0;')
  for (const tableName of tableNames) {
    await connection.query(`DROP TABLE IF EXISTS ${tableName};`)
  }

  await connection.close()
}

Hooks to bootstrap the app and clean up the DB between executions:

File jest.e2e-setup.ts - to be included to the jest configuration:

beforeAll(async () => {
  await dropTables()
  await createTestingModule()
})

afterAll(async () => {
  await closeTestingModule()
})

beforeEach(async () => {
  await cleanUpDb()
})

SQL migrations in TypeORM before a test suite

The setting is via migrationsRun. In this way, TypeORM runs SQL migrations.

App instance for test cases

describe('TagResolver (E2E)', () => {
  let app: INestApplication
  let userModel: UserModel

  beforeEach(async () => {
    app = getTestingModule()

    tagModel = app.get<TagModel>(TagModel)
  })

  it('verifies the app', () => {
    // ...
  })
})

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/api
  • @bull-board/express
  • express-basic-auth

Setup the board in the main file

In the main.ts file:

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

const serverAdapter = new ExpressAdapter()
serverAdapter.setBasePath('/bull-board')

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

createBullBoard({
  queues: [
    new BullAdapter(aQueue),
  ],
  serverAdapter,
})

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

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