How to allow null, but forbid undefined?

Question

e.g. for database rows, we may need nullable properties that must not be undefined:

class DbRow {
  @IsNumber()
  id!: number;

  @IsNumber()
  numNullable!: number | null;
}

So numNullable can be a number or null - but it must never be undefined.

How can we express this in class-validator?

• adding @Optional() does not work, because that would also allow undefined
• I also had no luck with a custom validator

Answer 1

It turns out that this is possible by using conditional validation ValidateIf:

class DbRow {
  @IsNumber()
  id!: number;

  @IsNumber()
  @ValidateIf((object, value) => value !== null)
  numNullable!: number | null;
}

Here is a stackblitz example

Answer 2

Here is my solution:

import { ValidationOptions, ValidateIf } from 'class-validator';
export function IsNullable(validationOptions?: ValidationOptions) {
  return ValidateIf((_object, value) => value !== null, validationOptions);
}

Usage

import { plainToClass } from 'class-transformer';
import { IsNumber, validateSync } from 'class-validator';
import { IsNullable } from 'src/common/utils/is-nullable.decorator';
class SampleDto {
  @IsNullable()
  @IsNumber()
  foo: number | null;
}
describe('IsNullable', () => {
  it('should disable other validators when given property is null', () => {
    expect(validateSync(plainToClass(SampleDto, { foo: null }))).toEqual([]);
  });
  it('should allow other validators to work when given property is not null', () => {
    expect(validateSync(plainToClass(SampleDto, { foo: 1 }))).toEqual([]);
    expect(validateSync(plainToClass(SampleDto, { foo: '1' }))[0].constraints.isNumber).toMatch('foo must be a number');
  });
  it('should not allow undefined', () => {
    expect(validateSync(plainToClass(SampleDto, { foo: undefined })).length).toBeGreaterThan(0);
  });
});

Answer 3

That's the limitation of the library, it doesn't allow condition branching. The best way is to write your own validator that allows only nulls.

Answer 4

This is an extended version of IsOptional exported from class-validator.

import {
  ValidationOptions,
  ValidateIf,
  IsOptional as IsOptionalValidator,
} from 'class-validator';

/**
 * Checks if value is missing and if so, ignores all validators.
 *
 * @param nullable If `true`, all other validators will be skipped even when the value is `null`. `false` by default.
 * @param validationOptions {@link ValidationOptions}
 *
 * @see IsOptional exported from `class-validator.
 */
export function IsOptional(
  nullable = false,
  validationOptions?: ValidationOptions,
) {
  if (nullable) {
    return IsOptionalValidator(validationOptions);
  }

  return ValidateIf((ob: any, v: any) => {
    return v !== undefined;
  }, validationOptions);
}