Kurs NestJS · Moduł 10: Walidacja danych

Custom Validators - Tworzenie własnych strażników

3 min czytania ·
W tej lekcji5

Wbudowane dekoratory class-validator pokrywają większość przypadków. Ale co jeśli potrzebujesz specjalistycznego strażnika, który sprawdza unikalne reguły twojego imperium? Czas nauczyć się tworzyć własnych strażników bramy!

@ValidatorConstraint - pełny custom validator

Najbardziej elastyczny sposób to stworzenie własnej klasy walidatora:

import {
  ValidatorConstraint,
  ValidatorConstraintInterface,
  ValidationArguments,
} from 'class-validator';

@ValidatorConstraint({ name: 'isRomanName', async: false })
export class IsRomanNameConstraint implements ValidatorConstraintInterface {
  validate(value: string, args: ValidationArguments): boolean {
    // Sprawdź czy imię zaczyna się od wielkiej litery
    // i zawiera tylko litery łacińskie
    return /^[A-Z][a-z]+$/.test(value);
  }

  defaultMessage(args: ValidationArguments): string {
    return 'Imię ($value) nie jest poprawnym imieniem rzymskim!';
  }
}

Klasa musi implementować interfejs ValidatorConstraintInterface z dwiema metodami:

  • validate() - zwraca true jeśli wartość jest poprawna
  • defaultMessage() - zwraca komunikat błędu

Użycie z @Validate()

import { Validate } from 'class-validator';

export class CreateLegionaryDto {
  @Validate(IsRomanNameConstraint)
  name: string;
}

Tworzenie dekoratora - czystszy sposób

Zamiast używać @Validate(), możesz stworzyć własny dekorator:

import {
  registerDecorator,
  ValidationOptions,
  ValidatorConstraint,
  ValidatorConstraintInterface,
} from 'class-validator';

@ValidatorConstraint({ async: false })
class IsLegionCodeConstraint implements ValidatorConstraintInterface {
  validate(value: string): boolean {
    return /^LEG-[IVXLCDM]+-\d{3}$/.test(value);
  }

  defaultMessage(): string {
    return 'Kod legionu musi mieć format LEG-[cyfry rzymskie]-[3 cyfry]';
  }
}

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

Teraz możesz używać go jak każdego innego dekoratora:

export class CreateLegionaryDto {
  @IsLegionCode({ message: 'Niepoprawny kod legionu!' })
  legionCode: string;
}

Walidatory asynchroniczne

Czasem walidacja wymaga dostępu do bazy danych (np. sprawdzenie czy nazwa jest unikalna). Wtedy tworzysz asynchroniczny walidator:

@ValidatorConstraint({ name: 'isUniqueRank', async: true })
export class IsUniqueRankConstraint implements ValidatorConstraintInterface {
  constructor(private readonly legionService: LegionService) {}

  async validate(rank: string): Promise<boolean> {
    // Sprawdź w bazie czy ranga jest dostępna
    const existing = await this.legionService.findByRank(rank);
    return !existing;
  }

  defaultMessage(): string {
    return 'Ta ranga jest już zajęta w legionie!';
  }
}

Uwaga: Asynchroniczne walidatory wymagają integracji z systemem Dependency Injection NestJS poprzez useContainer.

Walidacja krzyżowa pól

Możesz tworzyć walidatory, które sprawdzają relacje między polami:

@ValidatorConstraint({ async: false })
class IsAgeValidForRankConstraint implements ValidatorConstraintInterface {
  validate(value: any, args: ValidationArguments): boolean {
    const object = args.object as CreateLegionaryDto;
    // Legatus musi mieć co najmniej 30 lat
    if (object.rank === 'legatus' && object.age < 30) {
      return false;
    }
    // Centurio musi mieć co najmniej 25 lat
    if (object.rank === 'centurio' && object.age < 25) {
      return false;
    }
    return true;
  }

  defaultMessage(args: ValidationArguments): string {
    return 'Wiek nie odpowiada wymaganej randze!';
  }
}

Dzięki custom validatorom masz pełną kontrolę nad logiką walidacji. Twoi strażnicy bramy mogą teraz sprawdzać dowolne, nawet najbardziej złożone reguły!

Kod do tej lekcji: src/custom-validators.ts
// Custom Validators - Własni strażnicy bramy
import {
  ValidatorConstraint,
  ValidatorConstraintInterface,
  ValidationArguments,
  registerDecorator,
  ValidationOptions,
  Validate,
} from 'class-validator';

// TODO: Stwórz custom validator IsRomanName
// Reguła: imię musi zaczynać się wielką literą,
// zawierać min 2 znaki i tylko litery

@ValidatorConstraint({ name: 'isRomanName', async: false })
export class IsRomanNameConstraint
  implements ValidatorConstraintInterface
{
  validate(value: string, args: ValidationArguments): boolean {
    // TODO: Implementuj walidację
    // Sprawdź: /^[A-Z][a-zA-Z]{1,}$/.test(value)
    return true; // Zmień na poprawną implementację
  }

  defaultMessage(args: ValidationArguments): string {
    return 'Imię musi być poprawnym imieniem rzymskim!';
  }
}

// TODO: Stwórz dekorator IsLegionCode
// Format: LEG-[2-4 wielkie litery]-[3-4 cyfry]
export function IsLegionCode(options?: ValidationOptions) {
  return function (object: object, propertyName: string) {
    registerDecorator({
      target: object.constructor,
      propertyName,
      options,
      validator: {
        validate(value: string): boolean {
          // TODO: Zaimplementuj regex
          return /^LEG-[A-Z]{2,4}-\d{3,4}$/.test(value);
        },
        defaultMessage(): string {
          return 'Kod legionu musi mieć format LEG-XX-000';
        },
      },
    });
  };
}

// Użycie custom validatorów
class CreateLegionaryDto {
  @Validate(IsRomanNameConstraint)
  name: string;

  @IsLegionCode()
  legionCode: string;
}

console.log('Custom validators utworzone!');

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Jakie metody musi implementować klasa oznaczona @ValidatorConstraint?

  2. 2. Jak zastosować custom validator stworzony z @ValidatorConstraint na polu DTO?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj metodę validate w IsLatinTextConstraint tak, by sprawdzała regex /^[a-zA-Z .]+$/

  • Układanie w pionie

    Ułóż elementy tworzenia custom dekoratora walidacji w prawidłowej kolejności:

  • Edytor kodu

    Zaimplementuj logikę AgeForRankConstraint: legatus min 35, centurio min 25, miles min 16

  • Edytor kodu

    Zaimplementuj dekorator @IsRomanNumeral z użyciem registerDecorator

  1. PytanieInterfejs ValidatorConstraintInterface
  2. PytanieUżycie custom validatora
  3. Zadanie z kodemImplementacja custom validatora
  4. Ułóż w kolejnościStruktura registerDecorator
  5. Zadanie z kodemWalidacja krzyżowa pól
  6. PytanieAsynchroniczne custom walidatory
  7. Zadanie z kodemTworzenie własnego dekoratora walidacji

Przydatne artykuły