Today I Learned

18 posts by szymonkieloch

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 = [

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';

export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
      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:

      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(`${} - names: ${Object.getPrototypeOf(named).constructor.names}`)


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()

const aQueue = app.get<Queue>(

  queues: [
    new BullAdapter(aQueue),

    users: {
      user: 'password',
    challenge: true,

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

Issue with double quoted chars from terraform output

Sometime ago I noticed terraform outputs an error when running a make command:

╰─$ `terraform output gcloud_connection_command`
zsh: command not found: "gcloud

As it appeared, since the 0.14.0 version, terraform changed the way output formats the response. Since that release, terraform adds double back quotes around the returned text:

╰─$ terraform output gcloud_connection_command                                                                                                                                               
"gcloud container clusters get-credentials tilcra-staging-cluster --project tilcra --zone europe-west3-c"

To get back to the old output, add -raw flag to the command:

╰─$ terraform output -raw gcloud_connection_command
gcloud container clusters get-credentials tilcra-staging-cluster --project tilcra --zone europe-west3-

Loading React & Redux dev tools in Cypress

Install webpack plugin: npm install --save-dev react-dev-tools-iframe-webpack-plugin

Update webpack config to enable the react dev tools iframe:

const ReactDevToolsIFramePlugin = require('react-dev-tools-iframe-webpack-plugin');

plugins: [
  // other plugins,
  new ReactDevToolsIFramePlugin(),

Update cypress plugins to load React & Redux dev tools for chrome. Add the paths to these extensions in a comma-separated string:

module.exports = (on, config) => {
  on('before:browser:launch', (browser = {}, args) => {
    if ( === 'chrome') {
      return args;
    return null;

Here’s a post where you can find out where the extensions are.

Delete all local branches except the current one

From time to time it is necessary to delete all local branches. Assuming there are branches:

git branch --verbose

  a             2eb734f6 Update image tag
  b             2eb734f6 Update image tag
  first-branch  2eb734f6 Update image tag
  second-branch 2eb734f6 Update image tag
* staging       2eb734f6 Update image tag

This command will delete all branches except the current one:

git branch | grep -v `git symbolic-ref -q --short HEAD` | xargs git branch -D
Deleted branch a (was 2eb734f6).
Deleted branch b (was 2eb734f6).
Deleted branch first-branch (was 2eb734f6).
Deleted branch second-branch (was 2eb734f6).

An alias is handy:

alias gdal="git branch | grep -v `git symbolic-ref -q --short HEAD` | xargs git branch -D"

Waiting for content to be expanded in Cypress tests

When testing in Cypress, sometimes there are cases that content within accordion needs to be verified. The challenge is that sometimes, Cypress displays an error that an element is not yet visible, but it is on the page. A simple solution could be to wait for the element to be visible:

cy.contains('Text within the accordion')

One downside of this approach is that if there are more elements in the accordion, the last one should be check for visibility. Otherwise, Cypress will not wait for expanding the whole accordion and will proceed further with tests, e.g. trying to click an element that is not visible and hidden within the accordion.

An alternative approach to resolve the issue with the expanded accordions is to check its height and wait till it reaches a certain height:

  .should('', 700);