validation-api

TypeScript Validation Api, based on decorators.

Usage

import { Validate, ValidationError, IsBoolean } from 'validation-api';

@Validate()
class TestDomain {
  @IsBoolean()
  public booleanValue: boolean;

  constructor(entity: any) {
    this.booleanValue = entity.booleanValue;
  }
}

try {
  const success = new TestDomain({ booleanValue: false });
  const fail = new TestDomain({ booleanValue: 1 });
} catch (error) {
  if (error instanceof ValidationError) console.error(JSON.stringify(error));
  else throw error;
}

Property decorator

All decorator methods can take argument relevant to interface IPropDecoratorOption

interface IPropDecoratorOption {
  group?: string[];
  message?: string;
}

Decorators IsNumber, IsPositiveNumber, IsPositiveOrZeroNumber can take extended options

interface INumberPropDecorationOption extends IPropDecoratorOption {
  min?: number;
  max?: number;
}

Decorator IsMemberOf gets array of possible values

export interface IMemberOfPropDecorationOption extends IPropDecoratorOption {
  array: any[];
}

Decorators

• Required
• IsArray
• IsBoolean
• IsEmail
• IsMemberOf
• IsNumber
• IsPhone
• IsPositiveNumber
• IsPositiveOrZeroNumber
• IsString
• NotEmpty
• NotEmptyString

Abstract class

Complex validation

import {
  AbstractValidated,
  Validate,
  ValidationError,
  Required,
  IsBoolean,
  NotEmpty,
  IsPositiveNumber,
  NotEmptyString,
} from 'validation-api';

@Validate()
class Person extends AbstractValidated {
  @Required()
  @NotEmptyString({ message: 'Name is required for person' })
  public name: string;

  @IsPositiveNumber({ message: 'Person age must be a positive number' })
  public age: number;

  @IsBoolean()
  public ready: boolean;

  constructor(entity: any) {
    super(entity);
    this.name = entity.name;
    if (entity.age) {
      this.age = entity.age;
    } // If because setting to undefined throws a Validation error is not presented
    if (entity.ready) {
      this.ready = entity.ready;
    } // See above
  }
}

try {
  const success = new Person({ name: 'Ivan', age: 24, ready: true });
  const fail = new Person({ name: '', age: 0, ready: 1 });
} catch (error) {
  if (error instanceof ValidationError) {
    console.error(error.cause);
  } else {
    throw error;
  }
}

This example provides output in stderr:

[
  {
    constraint: 'NotEmptyString',
    message: 'Name is required for person',
    property: 'name',
    value: '',
  },
  {
    constraint: 'IsPositiveNumber',
    message: 'Person age must be a positive number',
    property: 'age',
    value: 0,
  },
  { constraint: 'IsBoolean', message: 'ready is not a Boolean', property: 'ready', value: 1 },
];