Skip to content

3. Das Action-Modell

Eine Action benötigt Informationen, die der Browser sendet: die URL-Parameter ([?name=martin&age=42]), Formularfelder und Routenparameter. Der ursprüngliche Kurs bezeichnet all diese Informationen als das Modell der Action. Dieses Kapitel zeigt, wie [NestJS] es der Action bereitstellt, es in den richtigen Typ umwandelt und validiert.

3.1. Beispiel 07: URL-Parameter

Die Datei [src/parameters.controller.ts]:

import { Controller, DefaultValuePipe, Get, ParseIntPipe, Query } from '@nestjs/common';

@Controller('parameters')
export class ParametersController {
  // /parameters/action01?name=martin
  @Get('action01')
  action01(@Query('name') name: string): string {
    return `name = [${name}], of type ${typeof name}`;
  }

  // /parameters/action02?age=42: ein Parameter ist IMMER ein String
  @Get('action02')
  action02(@Query('age') age: number): string {
    return `age = [${age}], of type ${typeof age}`;
  }

  // /parameters/action03?age=42: ParseIntPipe konvertiert (oder lehnt ab)
  @Get('action03')
  action03(@Query('age', ParseIntPipe) age: number): string {
    return `age = [${age}], of type ${typeof age}`;
  }

  // /parameters/action04?page=2: ein Standardwert, falls der Parameter fehlt
  @Get('action04')
  action04(@Query('page', new DefaultValuePipe(1), ParseIntPipe) page: number): string {
    return `page = [${page}], of type ${typeof page}`;
  }

  // /parameters/action05?name=martin&age=42: alle Parameter auf einmal
  @Get('action05')
  action05(@Query() parameters: Record<string, string>): object {
    return parameters;
  }
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeilen 6–9: [@Query('name')] injiziert den Wert des Parameters [name] aus der URL (der Teil nach [?], die Query-String oder [query string] genannt);
  • Zeilen 12–15: Der Parameter [age] ist mit dem Typ [number] deklariert ... doch dieser Typ ist lediglich eine [TypeScript]-Deklaration, die zur Kompilierzeit entfernt wird. Wir erhalten immer einen String, wie die Ausführung zeigt;
  • Zeilen 18–21: [ParseIntPipe] ist eine Pipe: ein Objekt, das den Wert eines Parameters umwandelt (und validiert), bevor er die Action erreicht. Hier wird der String ['42'] zur Zahl 42; ein nicht numerischer String führt zu einem 400-Fehler (Bad Request), ohne dass die Action ausgeführt wird;
  • Zeilen 24–27: Die Pipes werden verkettet: [DefaultValuePipe(1)] ersetzt einen fehlenden Parameter durch 1, anschließend wandelt [ParseIntPipe] ihn um;
  • Zeilen 30–33: [@Query()], ohne Argumente, injiziert ein Objekt, das alle Parameter der URL enthält.

Die Ergebnisse:

curl -i "http://localhost:3000/parameters/action01?name=martin"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 31

name = [martin], of type string
curl -i "http://localhost:3000/parameters/action01"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 37

name = [undefined], of type undefined
curl -i "http://localhost:3000/parameters/action02?age=42"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 26

age = [42], of type string
curl -i "http://localhost:3000/parameters/action03?age=42"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 26

age = [42], of type number
curl -i "http://localhost:3000/parameters/action03?age=abc"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 99

{"message":"Validation failed (numeric string is expected)","error":"Bad Request","statusCode":400}
curl -i "http://localhost:3000/parameters/action04"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 26

page = [1], of type number
curl -i "http://localhost:3000/parameters/action04?page=2"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 26

page = [2], of type number
curl -i "http://localhost:3000/parameters/action05?name=martin&age=42"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 28

{"name":"martin","age":"42"}

Die Anführungszeichen um die URL sind notwendig, wenn sie das Zeichen [&] enthält, das für die Konsole eine besondere Bedeutung hat. Beachten Sie Folgendes:

  • Ein fehlender Parameter wird als [undefined] behandelt;
  • Ein vorhandener Parameter ist unabhängig vom deklarierten Typ ein String;
  • Eine Pipe dient dazu, einen Parameter umzuwandeln und zu validieren, und liefert den Statuscode 400, wenn der Wert ungültig ist.

Image

3.2. Beispiel 08: Ein durch eine Klasse beschriebenes Action-Modell

Hat eine Action mehrere Parameter, werden sie durch eine Klasse beschrieben, die oft [DTO] ([Data Transfer Object]) genannt wird. Jedes Feld der Klasse hat Validierungsdekoratoren aus der Bibliothek [class-validator]. Diese entsprechen den Attributen [[Required]], [[Range]] usw. von [ASP.NET MVC].

Die Datei [src/person.dto.ts]:

import { Type } from 'class-transformer';
import { IsEmail, IsIn, IsInt, IsNotEmpty, IsOptional, Length, Max, Min } from 'class-validator';

export class PersonDto {
  @IsNotEmpty({ message: 'the name is required' })
  @Length(2, 20, { message: 'the name must have 2 to 20 characters' })
  name: string;

  @Type(() => Number)
  @IsInt({ message: 'the age must be an integer' })
  @Min(0, { message: 'the age must be positive' })
  @Max(150, { message: 'the age cannot exceed 150' })
  age: number;

  @IsIn(['Mr', 'Mme', 'Melle'], { message: 'unknown title' })
  title: string;

  @IsOptional()
  @IsEmail({}, { message: 'invalid email address' })
  email?: string;
}

Gehen wir diesen Code im Einzelnen durch:

  • Zeile 1: [@Type] stammt aus der Bibliothek [class-transformer], die die empfangenen Daten umwandelt;
  • Zeile 2: die Validierungsdekoratoren aus [class-validator];
  • Zeilen 5–7: Der Name ist erforderlich ([@IsNotEmpty]) und muss zwischen 2 und 20 Zeichen lang sein ([@Length]). Jeder Dekorator akzeptiert eine eigene Fehlermeldung;
  • Zeilen 9–13: [@Type(() => Number)] verlangt, dass der empfangene String vor der Validierung in eine Zahl umgewandelt wird: eine ganze Zahl ([@IsInt]) zwischen 0 und 150 ([@Min], [@Max]);
  • Zeilen 15–16: Die Anrede muss einer der Werte einer Liste sein;
  • Zeilen 18–20: Die E-Mail-Adresse ist optional ([@IsOptional]); falls vorhanden, muss sie gültig sein ([@IsEmail]).

Die Datei [src/persons.controller.ts]:

import { Controller, Get, Query } from '@nestjs/common';
import { PersonDto } from './person.dto';

@Controller('persons')
export class PersonsController {
  // /persons/action01?name=martin&age=42&title=Mr
  @Get('action01')
  action01(@Query() person: PersonDto): object {
    return {
      person,
      ageType: typeof person.age,
      isAPersonDto: person instanceof PersonDto,
    };
  }
}

Zeile 8: Die Action erhält ein [PersonDto]. Die Action gibt die empfangene Person und den Typ ihres Alters zurück und prüft, dass es sich tatsächlich um eine Instanz der Klasse [PersonDto] handelt.

Damit die Dekoratoren der Klasse angewendet werden, muss die Validierung einmalig und global in [main.ts] aktiviert werden:

Die Datei [src/main.ts]:

import { NestFactory } from '@nestjs/core';
import { ValidationPipe } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  // automatische Validierung ALLER Action-Modelle, die durch eine Klasse beschrieben sind
  app.useGlobalPipes(
    new ValidationPipe({
      transform: true, // konvertiert die empfangenen Strings in die deklarierten Typen
      whitelist: true, // entfernt die in der Klasse nicht deklarierten Felder
    }),
  );
  await app.listen(3000);
  console.log('Server started on http://localhost:3000');
}

bootstrap();
  • Zeilen 8–13: Eine globale Pipe, [ValidationPipe], wird auf alle Parameter aller Actions angewendet. Bei einem Parameter, dessen Typ eine Klasse ist, prüft sie die Einschränkungen ihrer Dekoratoren;
  • Zeile 10: [transform: true]: Die Action erhält eine echte Instanz von [PersonDto], deren Felder umgewandelt wurden ([@Type]);
  • Zeile 11: [whitelist: true]: Parameter, die keinem Feld der Klasse entsprechen, werden entfernt.

Eine gültige Anfrage mit einem Parameter ([pirate]), der nicht in der Klasse deklariert ist:

curl -i "http://localhost:3000/persons/action01?name=martin&age=42&title=Mr&pirate=1"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 89

{"person":{"name":"martin","age":42,"title":"Mr"},"ageType":"number","isAPersonDto":true}

Das Alter ist tatsächlich zu einer Zahl geworden, und der Parameter [pirate] ist verschwunden. Eine ungültige Anfrage:

curl -i "http://localhost:3000/persons/action01?name=m&age=abc&title=Dr&email=xx"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 216

{"message":["the name must have 2 to 20 characters","the age cannot exceed 150","the age must be positive","the age must be an integer","unknown title","invalid email address"],"error":"Bad Request","statusCode":400}

[ValidationPipe] hat die Anfrage mit einem 400-Fehler abgelehnt, dessen Rumpf (JSON) die Fehlermeldungen auflistet. Die Action wurde nicht ausgeführt. Dasselbe Ergebnis erhalten wir ohne jegliche Parameter:

curl -i http://localhost:3000/persons/action01
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 215

{"message":["the name must have 2 to 20 characters","the name is required","the age cannot exceed 150","the age must be positive","the age must be an integer","unknown title"],"error":"Bad Request","statusCode":400}

Dieses Verhalten ist für einen JSON-Server zu erwarten, der von einem [JavaScript]-Client abgefragt wird, der Fehler auf seine eigene Weise anzeigt. Bei einer HTML-Anwendung ergibt ein JSON mit Fehlern keinen Sinn: Wir möchten das Formular mit seinen Fehlern erneut anzeigen. Das folgende Beispiel zeigt, wie man die Kontrolle übernimmt.

3.3. Beispiel 09: Von der Action durchgeführte Validierung

Beispiel 09 hat keine globale [ValidationPipe]. Die Action wandelt das Modell selbst um und validiert es mit denselben Dekoratoren (die Datei [person.dto.ts] ist identisch):

Die Datei [src/persons.controller.ts]:

import { Controller, Get, Query } from '@nestjs/common';
import { plainToInstance } from 'class-transformer';
import { validate } from 'class-validator';
import { PersonDto } from './person.dto';

@Controller('persons')
export class PersonsController {
  // keine ValidationPipe hier: die Action erhält die ROHEN Parameter und
  // entscheidet selbst, wie sie mit den Fehlern umgeht
  @Get('action01')
  async action01(@Query() raw: Record<string, string>): Promise<string> {
    // 1. rohes Objekt -> PersonDto-Instanz (inklusive @Type-Konvertierungen)
    const person = plainToInstance(PersonDto, raw);
    // 2. Prüfung der Constraints (@IsNotEmpty, @Min ...)
    const errors = await validate(person);
    // 3. in beiden Fällen eine HTML-Seite: kein 400-Fehler
    if (errors.length === 0) {
      return `<p>Welcome ${person.title} ${person.name} (${person.age} years old)</p>`;
    }
    const items = errors
      .map((e) => `<li>${e.property}: ${Object.values(e.constraints ?? {}).join(', ')}</li>`)
      .join('');
    return `<p>The form contains errors:</p><ul>${items}</ul>`;
  }
}

Kommentieren wir diesen Code:

  • Zeile 11: Die Action erhält die rohen Parameter: ein Objekt, dessen Felder alle Strings sind;
  • Zeile 13: [plainToInstance] ([class-transformer]) erzeugt aus dem rohen Objekt eine Instanz von [PersonDto] und wendet dabei die Umwandlungen an ([@Type]);
  • Zeile 15: [validate] ([class-validator]) prüft alle Einschränkungen. Es gibt ein Array mit Fehlern zurück, das leer ist, wenn alles in Ordnung ist. Jeder Fehler nennt das betroffene Feld ([property]) und die Meldungen der verletzten Einschränkungen ([constraints]);
  • Zeilen 17–18: keine Fehler – eine Willkommensseite;
  • Zeilen 20–23: andernfalls eine Seite, die die Fehler auflistet. In beiden Fällen ist die Antwort eine HTML-Seite mit dem Statuscode 200.

Image

Image

Dies ist die Technik, die alle Formulare der Fallstudie verwenden werden (siehe Beispiel 19).

3.4. Beispiel 10: Mehrfache Parameter

Ein einzelner Parameter kann in einer Anfrage mehrfach vorkommen: Das ist bei Kontrollkästchen in einem Formular oder einer Mehrfachauswahlliste der Fall ([?color=red&color=green]).

Die Datei [src/arrays.controller.ts]:

import { Controller, Get, Query } from '@nestjs/common';
import { ChoiceDto } from './choice.dto';

@Controller('arrays')
export class ArraysController {
  // /arrays/action01?color=red&color=green: was Express empfängt
  @Get('action01')
  action01(@Query('color') color: string | string[]): object {
    return { color, isAnArray: Array.isArray(color) };
  }

  // /arrays/action02?color=red: dank ChoiceDto immer ein Array
  @Get('action02')
  action02(@Query() choice: ChoiceDto): object {
    return { colors: choice.color, count: choice.color.length };
  }
}

Die Action [action01] (Zeilen 7–10) zeigt, was eine Action empfängt:

curl -i "http://localhost:3000/arrays/action01?color=red"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 33

{"color":"red","isAnArray":false}
curl -i "http://localhost:3000/arrays/action01?color=red&color=green"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 42

{"color":["red","green"],"isAnArray":true}

Der Typ hängt von der Anzahl der Werte ab: ein String bei einem einzelnen Wert, ein Array bei mehreren Werten. Das ist eine häufige Falle. Die Klasse [ChoiceDto] behandelt beide Fälle als Array:

Die Datei [src/choice.dto.ts]:

import { Transform } from 'class-transformer';
import { ArrayMinSize, IsArray, IsIn } from 'class-validator';

export class ChoiceDto {
  // ?color=red -> "red"; ?color=red&color=green -> ["red","green"]
  // @Transform macht in beiden Fällen ein Array daraus
  @Transform(({ value }) => (Array.isArray(value) ? value : [value]))
  @IsArray()
  @ArrayMinSize(1, { message: 'choose at least one color' })
  @IsIn(['red', 'green', 'blue'], { each: true, message: 'unknown color' })
  color: string[];
}
  • Zeile 7: [@Transform] ([class-transformer]) wendet eine Umwandlungsfunktion auf das Feld an: Ein einzelner Wert wird in ein Array gelegt;
  • Zeile 8: Das Feld muss ein Array sein ...
  • Zeile 9: ... mit mindestens einem Element ...
  • Zeile 10: ... und jedes Element ([each: true]) muss in der Liste enthalten sein.
curl -i "http://localhost:3000/arrays/action02?color=red"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 28

{"colors":["red"],"count":1}
curl -i "http://localhost:3000/arrays/action02?color=red&color=green"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 36

{"colors":["red","green"],"count":2}
curl -i "http://localhost:3000/arrays/action02?color=red&color=black"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 68

{"message":["unknown color"],"error":"Bad Request","statusCode":400}

3.5. Beispiel 11: Parameter einer POST-Anfrage

Ein per POST-Methode gesendetes HTML-Formular legt seine Felder in den Rumpf der Anfrage, nicht in die URL. Der Dekorator [@Body] ersetzt dann [@Query]:

Die Datei [src/post.controller.ts]:

import { Body, Controller, Headers, Post } from '@nestjs/common';
import { PersonDto } from './person.dto';

@Controller('post')
export class PostController {
  // der Anfragekörper, unverändert
  @Post('action01')
  action01(@Body() body: Record<string, unknown>, @Headers('content-type') type: string): object {
    return { receivedType: type, body };
  }

  // ein einzelnes Feld des Anfragekörpers
  @Post('action02')
  action02(@Body('name') name: string): string {
    return `name = [${name}]`;
  }

  // der Anfragekörper, konvertiert und validiert durch die Klasse PersonDto
  @Post('action03')
  action03(@Body() person: PersonDto): object {
    return { person, ageType: typeof person.age };
  }
}
  • Zeilen 7–10: [@Body()] injiziert den Rumpf der Anfrage, der bereits von [NestJS] dekodiert wurde. [@Headers('content-type')] injiziert einen Header der Anfrage: den Typ des Rumpfs;
  • Zeilen 13–16: [@Body('name')] injiziert ein einzelnes Feld aus dem Rumpf;
  • Zeilen 19–22: Wie bei [@Query] kann der Rumpf durch eine Klasse beschrieben und von der globalen [ValidationPipe] validiert werden.

Die Option [-d] von [curl] sendet eine POST-Anfrage mit einem Rumpf im Format eines HTML-Formulars ([application/x-www-form-urlencoded]):

curl -i -d "name=martin&age=42" http://localhost:3000/post/action01
1
2
3
4
5
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Content-Length: 88

{"receivedType":"application/x-www-form-urlencoded","body":{"name":"martin","age":"42"}}

Derselbe Rumpf im JSON-Format (das sendet ein Client in [JavaScript]):

curl -i -H "Content-Type: application/json" -d '{"name":"martin","age":42}' http://localhost:3000/post/action01
1
2
3
4
5
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Content-Length: 69

{"receivedType":"application/json","body":{"name":"martin","age":42}}

[NestJS] dekodiert beide Formate. Beachten Sie, dass „age“ im ersten Fall ein String ist (ein HTML-Formular überträgt nur Text) und im zweiten Fall eine Zahl. Die beiden anderen Actions:

curl -i -d "name=martin&age=42" http://localhost:3000/post/action02
1
2
3
4
5
HTTP/1.1 201 Created
Content-Type: text/html; charset=utf-8
Content-Length: 15

name = [martin]
curl -i -d "name=martin&age=42&title=Mme" http://localhost:3000/post/action03
1
2
3
4
5
HTTP/1.1 201 Created
Content-Type: application/json; charset=utf-8
Content-Length: 70

{"person":{"name":"martin","age":42,"title":"Mme"},"ageType":"number"}
curl -i -d "name=martin&age=200" http://localhost:3000/post/action03
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 96

{"message":["the age cannot exceed 150","unknown title"],"error":"Bad Request","statusCode":400}

Der Code 201 (Created) ist für [NestJS] der Standardcode für ein POST. Bei einer HTML-Anwendung antwortet eine POST-Action entweder mit einer Seite (dann wird [@HttpCode(200)] hinzugefügt) oder mit einer Weiterleitung (siehe Beispiel 20).

3.6. Beispiel 12: Eigene Pipes und Dekoratoren

Sie können eigene Pipes und Parameterdekoratoren schreiben. Die Fallstudie nutzt sie nur in Maßen, aber sie zu verstehen hilft, die von [NestJS] zu verstehen.

3.6.1. Eine Pipe: DateFrPipe

Die Datei [src/date-fr.pipe.ts]:

import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';

// wandelt ein französisches Datum "23/09/2026" in ein ISO-Datum "2026-09-23" um
@Injectable()
export class DateFrPipe implements PipeTransform<string, string> {
  transform(value: string): string {
    const m = /^(\d{2})\/(\d{2})\/(\d{4})$/.exec(value ?? '');
    if (!m) {
      throw new BadRequestException(`[${value}] is not a date in the dd/mm/yyyy format`);
    }
    const [, day, month, year] = m;
    const iso = `${year}-${month}-${day}`;
    // "31/02/2026" hat die richtige Form, existiert aber nicht
    if (new Date(`${iso}T00:00:00Z`).toISOString().slice(0, 10) !== iso) {
      throw new BadRequestException(`the date [${value}] does not exist`);
    }
    return iso;
  }
}
  • Zeilen 4–5: Eine Pipe ist eine Klasse mit [@Injectable()] , die das Interface [PipeTransform<input, output>] implementiert;
  • Zeile 6: Ihre Methode [transform] erhält den Wert des Parameters und gibt den umgewandelten Wert zurück, den die Action empfängt;
  • Zeilen 7–9: Ein Wert, der nicht die Form [dd/mm/yyyy] hat, löst eine [BadRequestException] (400) aus;
  • Zeilen 13–15: Ein Datum, das im richtigen Format vorliegt, aber nicht existiert (31/02/2026), wird ebenfalls abgelehnt: [new Date] „korrigiert“ es auf den 03/03/2026, was erkannt wird.

3.6.2. Ein Parameterdekorator: @Language()

Die Datei [src/language.decorator.ts]:

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { Request } from 'express';

// @Language(): die bevorzugte Sprache des Browsers, aus dem Header gelesen
// "Accept-Language: fr-FR,fr;q=0.9,en;q=0.8" -> "fr"
export const Language = createParamDecorator((fallback: string | undefined, ctx: ExecutionContext): string => {
  const req = ctx.switchToHttp().getRequest<Request>();
  const header = req.get('accept-language') ?? '';
  const first = header.split(',')[0].trim().slice(0, 2).toLowerCase();
  return first || fallback || 'fr';
});
  • Zeile 6: [createParamDecorator] erzeugt einen Parameterdekorator, ähnlich wie [@Query] oder [@Body]. Die Funktion erhält das Argument des Dekorators ([@Language('fr')]) und den Ausführungskontext der Anfrage;
  • Zeile 7: Der Kontext ermöglicht den Zugriff auf die [Express]-Anfrage;
  • Zeilen 8–10: Es werden die ersten zwei Buchstaben des Headers [Accept-Language] zurückgegeben, der die bevorzugten Sprachen des Benutzers angibt.

3.6.3. Der Controller

Die Datei [src/examples.controller.ts]:

import { Controller, Get, Query } from '@nestjs/common';
import { DateFrPipe } from './date-fr.pipe';
import { Language } from './language.decorator';
import { SearchDto } from './search.dto';

@Controller('examples')
export class ExamplesController {
  // /examples/schedule?day=23/09/2026: eine eigene Pipe
  @Get('schedule')
  schedule(@Query('day', DateFrPipe) day: string): string {
    return `schedule for the day [${day}]`;
  }

  // /examples/hello: ein eigener Parameter-Dekorator
  @Get('hello')
  hello(@Language('fr') language: string): string {
    return language === 'en' ? 'Hello!' : 'Bonjour !';
  }

  // /examples/search?keyword=nest&admin=true: [admin] ist nicht deklariert
  @Get('search')
  search(@Query() search: SearchDto): object {
    return search;
  }
}
  • Zeile 10: Die Pipe wird wie [ParseIntPipe] verwendet;
  • Zeile 16: Der Dekorator wird wie [@Query] verwendet;
  • Zeile 22: ein durch eine Klasse beschriebenes Modell, diesmal mit der Option [forbidNonWhitelisted] der [ValidationPipe] (Datei [main.ts] weiter unten).

Die Datei [src/main.ts]:

import { NestFactory } from '@nestjs/core';
import { ValidationPipe } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(
    new ValidationPipe({
      transform: true,
      whitelist: true, // die nicht deklarierten Felder werden entfernt ...
      forbidNonWhitelisted: true, // ... oder mit dieser Option abgelehnt (400)
    }),
  );
  await app.listen(3000);
  console.log('Server started on http://localhost:3000');
}

bootstrap();

Zeile 11: Mit [forbidNonWhitelisted: true] wird ein in der Klasse nicht deklarierter Parameter nicht mehr stillschweigend entfernt, sondern führt zu einem 400-Fehler.

Die Ergebnisse:

curl -i "http://localhost:3000/examples/schedule?day=23/09/2026"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 33

schedule for the day [2026-09-23]
curl -i "http://localhost:3000/examples/schedule?day=2026-09-23"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 104

{"message":"[2026-09-23] is not a date in the dd/mm/yyyy format","error":"Bad Request","statusCode":400}
curl -i "http://localhost:3000/examples/schedule?day=31/02/2026"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 89

{"message":"the date [31/02/2026] does not exist","error":"Bad Request","statusCode":400}
curl -i -H "Accept-Language: fr-FR,fr;q=0.9" http://localhost:3000/examples/hello
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 9

Bonjour !
curl -i -H "Accept-Language: en-US,en;q=0.9" http://localhost:3000/examples/hello
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
Content-Length: 6

Hello!
curl -i "http://localhost:3000/examples/search?keyword=nest"
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 18

{"keyword":"nest"}
curl -i "http://localhost:3000/examples/search?keyword=nest&admin=true"
1
2
3
4
5
HTTP/1.1 400 Bad Request
Content-Type: application/json; charset=utf-8
Content-Length: 86

{"message":["property admin should not exist"],"error":"Bad Request","statusCode":400}

(Die Option [-H] von [curl] fügt der Anfrage einen Header hinzu)

3.6.4. Fazit

Das Action-Modell wird von [NestJS] anhand der Anfrage erzeugt: Routenparameter ([@Param]), URL ([@Query]), der Rumpf ([@Body]) und Header ([@Headers]). Die Pipes wandeln diese Werte um und validieren sie. Bei einer HTML-Anwendung ist es meist vorzuziehen, das Modell selbst zu validieren (Beispiel 09), damit Sie das Formular erneut anzeigen können. Das ist das Thema des nächsten Kapitels.