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"
|
| 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"
|
| 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"
|
| 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"
|
| 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"
|
| 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"
|
| 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"
|
| 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"
|
| 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.

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"
|
| 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"
|
| 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
|
| 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.


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"
|
| 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"
|
| 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"
|
| 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"
|
| 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"
|
| 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
|
| 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
|
| 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
|
| 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
|
| 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
|
| 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"
|
| 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"
|
| 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"
|
| 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
|
| 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
|
| 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"
|
| 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"
|
| 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.