typescript 61 lines · 10 steps

A custom validation pipe in NestJS

A NestJS pipe that strips undefined values before transforming and validating incoming DTOs.

Explained by highlit

NestJS Intermediate validation dto recursion data-sanitization class-validator

1import {
Injectable,
PipeTransform,
ArgumentMetadata,
BadRequestException,
6} from '@nestjs/common';
7import { plainToInstance } from 'class-transformer';
8import { validate } from 'class-validator';
9 
10@Injectable()
11export class StripUndefinedValidationPipe implements PipeTransform {
async transform(value: unknown, { metatype }: ArgumentMetadata) {
  if (!metatype || !this.shouldValidate(metatype)) {
    return value;
  }
16 
  const pruned = this.stripUndefined(value);
  const instance = plainToInstance(metatype, pruned, {
    exposeUnsetFields: false,
  });
21 
  const errors = await validate(instance as object, {
    whitelist: true,
    forbidNonWhitelisted: true,
    skipMissingProperties: true,
  });
27 
  if (errors.length > 0) {
    throw new BadRequestException(
      errors.flatMap((e) => Object.values(e.constraints ?? {})),
    );
  }
33 
  return instance;
}
36 
private shouldValidate(metatype: Function): boolean {
  const primitives: Function[] = [String, Boolean, Number, Array, Object];
  return !primitives.includes(metatype);
}
41 
private stripUndefined(input: unknown): unknown {
  if (Array.isArray(input)) {
    return input.map((item) => this.stripUndefined(item));
  }
46 
  if (input !== null && typeof input === 'object') {
    return Object.entries(input as Record<string, unknown>).reduce(
      (acc, [key, val]) => {
        if (val !== undefined) {
          acc[key] = this.stripUndefined(val);
        }
        return acc;
      },
      {} as Record<string, unknown>,
    );
  }
58 
  return input;
}
61}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Implementing PipeTransform lets you inject custom sanitization logic into NestJS's request lifecycle before controllers run.
2Pruning undefined keys before validation keeps whitelist rules from misfiring on properties that were never really sent.
3Recursion handles nested objects and arrays uniformly so the same cleaning rule applies at every depth.

Related explainers

typescript

import { registerLocaleData } from '@angular/common';
import localeFr from '@angular/common/locales/fr';
import localeFrExtra from '@angular/common/locales/extra/fr';
import localeDe from '@angular/common/locales/de';

Locale-aware bootstrapping in Angular

i18n localization dependency-injection

Intermediate 8 steps

typescript

import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import * as Joi from 'joi';

Validating env config at boot in NestJS

configuration schema-validation environment-variables

Intermediate 8 steps

php

<?php
 
namespace App\Services\Checkout;

Validating coupons with Laravel's Pipeline

pipeline chain of responsibility transactions

Intermediate 7 steps

javascript

function evaluate(expression) {
  const tokens = tokenize(expression);
  let pos = 0;

Building a recursive descent calculator

parsing recursion operator-precedence

Intermediate 8 steps

typescript

import { Inject, Injectable, Logger } from '@nestjs/common';
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Cache } from 'cache-manager';
import { InjectRepository } from '@nestjs/typeorm';