Class ValidatorsImpl

src/chain/validators-impl.ts:8–373

import { ExistsOptions, Validators } from './validators';

export class ValidatorsImpl<Chain> implements Validators<Chain> {
  private lastValidator: CustomValidation | StandardValidation;
  private negateNext = false;

  constructor(private readonly builder: ContextBuilder, private readonly chain: Chain) {}

  private addItem(item: CustomValidation | StandardValidation) {
    this.builder.addItem(item);
    this.lastValidator = item;
    // Reset this.negateNext so that next validation isn't negated too
    this.negateNext = false;

    return this.chain;
  }

  // validation manipulation
  not() {
    this.negateNext = true;
    return this.chain;
  }

  withMessage(message: FieldMessageFactory | ErrorMessage) {
    this.lastValidator.message = message;
    return this.chain;
  }

  // custom validators
  custom(validator: CustomValidator) {
    return this.addItem(new CustomValidation(validator, this.negateNext));
  }

  exists(options: ExistsOptions = {}) {
    let validator: CustomValidator;
    if (options.checkFalsy || options.values === 'falsy') {
      validator = value => !!value;
    } else if (options.checkNull || options.values === 'null') {
      validator = value => value != null;
    } else {
      validator = value => value !== undefined;
    }

    return this.custom(validator);
  }

  isArray(options: { min?: number; max?: number } = {}) {
    return this.custom(
      value =>
        Array.isArray(value) &&
        (typeof options.min === 'undefined' || value.length >= options.min) &&
        (typeof options.max === 'undefined' || value.length <= options.max),
    );
  }

  isObject(options: { strict?: boolean } = { strict: true }) {
    return this.custom(
      value =>
        typeof value === 'object' &&
        (options.strict == null || options.strict ? value !== null && !Array.isArray(value) : true),