@appolo/validator v8.0.5

Class Validator

Validation module for appolo. Validate any method or argument using class-validator and class-transformer

Installation

npm i @appolo/validator

Options

in config/modules/all.ts

import {App} from 'appolo';
import {ValidationModule} from '@appolo/validator';

export = async function (app:App) {
    await app.module(new ValidationModule());
}

Validate

Validate method

if valid the query object will be converted to given model

import {controller,inject,Controller,query,get} from 'appolo';
import {validate,IsString} from '@appolo/validation';

class SomeModel {
  @IsString()  
  name:string
}

@controller()
export class TestController extends Controller{
    @inject() dataManager:DataManager;

    @get("/search/")
    @validate()
    public async search (@query() query:SomeModel) {
        return await this.dataManager.search(query.name)
    }
}

Validate argument

import {define,inject,Controller,query,get} from 'appolo';
import {validate,IsString} from '@appolo/validation';

@define()
export class TestController extends Controller{
    @inject() dataManager:DataManager
    
    @get("/search/")
    public async search (@validate() @query() query:SomeModel) {
        return await this.dataManager.search(query.name)
    }
}

Validate custom model

import {define,inject} from 'appolo';
import {validate} from '@appolo/validation';

@define()
export class SomeManager{
    public async search (@validate(SomeModel) model:any) {
        // do something
    }
}

Validate with options

import {define} from 'appolo';
import {validate} from '@appolo/validation';

@define()
export class SomeManager{
    public async search (@validate(SomeModel,{groups:["someGroup"]}) model:any) {
        // do something
    }
}

Validation Error

If validation fails BadRequestError will be thrown

• message will be formatted using validationErrorFormat options

• data - array of ValidationError

  [{
      target: Object,
      property: "title",
      value: "Hello",
      constraints: {
          length: "$property must be longer than or equal to 10 characters"
      }
  }]

Custom Validator

you can define custom validator using appolo injector

import {registerDecorator,ValidationArguments,ValidationOptions,ValidatorConstraint,ValidatorConstraintInterface} from "class-validator";
import {define,inject} from 'appolo';

@define()
@ValidatorConstraint({async: true})
export class IsValidUserNameConstraint implements ValidatorConstraintInterface {
    
    @inject() userRepository:UserRepository;
    
    async validate(value: any, args: ValidationArguments) {
        let user = await this.userRepository.findOneByName(value)
            
        return !!user
    }
}

export function IsValidUserName(validationOptions?: ValidationOptions) {
    return function (object: Object, propertyName: string) {
        registerDecorator({
            target: object.constructor,
            propertyName: propertyName,
            options: validationOptions,
            constraints: [],
            validator: IsValidUserNameConstraint
        });
    };
}

Transform

Transform Argument to given model

import {controller,inject} from 'appolo';
import {transform,IsString} from '@appolo/validation';

class SomeModel {
  @IsString()  
  name:string
}

@define()
export class SomeManager{
    public async search (@transform(SomeModel) model:any) {
        // do something
    }
}

Transform After

Transform the return value to given model

import {controller,inject} from 'appolo';
import {transform,IsString,transformAfter} from '@appolo/validation';

class SomeModel {
  @IsString()  
  name:string
}

@define()
export class SomeManager{
    @transformAfter(SomeModel)
    public async search (model:any) {
        return model;
    }
}