3. O modelo da ação
Uma ação precisa de informações enviadas pelo navegador: os parâmetros da URL ([?name=martin&age=42]), os campos de formulário e os parâmetros de rota. O curso original designa todas essas informações como o modelo da ação. Este capítulo mostra como o [NestJS] o fornece à ação, o converte para o tipo correto e o valida.
3.1. Exemplo 07: Parâmetros da URL
O arquivo [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: um parâmetro é SEMPRE uma string
@Get('action02')
action02(@Query('age') age: number): string {
return `age = [${age}], of type ${typeof age}`;
}
// /parameters/action03?age=42: ParseIntPipe converte (ou rejeita)
@Get('action03')
action03(@Query('age', ParseIntPipe) age: number): string {
return `age = [${age}], of type ${typeof age}`;
}
// /parameters/action04?page=2: um valor padrão se o parâmetro estiver ausente
@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: todos os parâmetros de uma vez
@Get('action05')
action05(@Query() parameters: Record<string, string>): object {
return parameters;
}
}
|
Vamos detalhar este código:
- Linhas 6–9: [@Query('name')] injeta o valor do parâmetro [name] da URL (a parte que segue [?], chamada de a query string ou [query string]);
- linhas 12–15: o parâmetro [age] é declarado com o tipo [number]... mas esse tipo é apenas uma declaração [TypeScript], que é removida na compilação. O que recebemos é sempre uma string, como mostra a execução;
- linhas 18–21: [ParseIntPipe] é um pipe: um objeto que transforma (e valida) o valor de um parâmetro antes que ele chegue à ação. Aqui, a string ['42'] se torna o número 42; uma string não numérica causa um erro 400 (Bad Request), sem que a ação seja executada;
- linhas 24–27: os pipes são encadeados: [DefaultValuePipe(1)] substitui um parâmetro ausente por 1 e, em seguida, [ParseIntPipe] o converte;
- linhas 30–33: [@Query()], sem nenhum argumento, injeta um objeto contendo todos os parâmetros da URL.
Os resultados:
| 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"}
|
As aspas em torno da URL são necessárias quando ela contém o caractere [&], que tem um significado específico para o console. Observe que:
- um parâmetro ausente é tratado como [undefined];
- um parâmetro presente é uma string, independentemente do tipo declarado;
- um pipe serve para converter e validar um parâmetro e retorna o código de status 400 se o valor for inválido.

3.2. Exemplo 08: Um modelo de ação descrito por uma classe
Quando uma ação tem vários parâmetros, eles são descritos por uma classe, frequentemente chamada de [DTO] ([Data Transfer Object]). Cada campo da classe recebe decoradores de validação fornecidos pela biblioteca [class-validator]. Eles equivalem aos atributos [[Required]], [[Range]]..., etc., do [ASP.NET MVC].
O arquivo [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;
}
|
Vamos detalhar este código:
- linha 1: [@Type] vem da biblioteca [class-transformer], que converte os dados recebidos;
- linha 2: os decoradores de validação do [class-validator];
- linhas 5–7: o nome é obrigatório ([@IsNotEmpty]) e deve ter entre 2 e 20 caracteres ([@Length]). Cada decorador aceita uma mensagem de erro personalizada;
- linhas 9–13: [@Type(() => Number)] exige que a string recebida seja convertida em número antes da validação: um inteiro ([@IsInt]) entre 0 e 150 ([@Min], [@Max]);
- linhas 15–16: o título deve ser um dos valores de uma lista;
- linhas 18–20: o endereço de e-mail é opcional ([@IsOptional]); se presente, deve ser válido ([@IsEmail]).
O arquivo [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,
};
}
}
|
linha 8: a ação recebe um [PersonDto]. A ação retorna a pessoa recebida, o tipo de sua idade e verifica que ela é de fato uma instância da classe [PersonDto].
Para garantir que os decoradores da classe sejam aplicados, a validação deve ser ativada de uma vez por todas em [main.ts]:
O arquivo [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);
// validação automática de TODOS os modelos de action descritos por uma classe
app.useGlobalPipes(
new ValidationPipe({
transform: true, // converte as strings recebidas nos tipos declarados
whitelist: true, // remove os campos não declarados na classe
}),
);
await app.listen(3000);
console.log('Server started on http://localhost:3000');
}
bootstrap();
|
- linhas 8–13: Um pipe global, o [ValidationPipe], é aplicado a todos os parâmetros de todas as ações. Para um parâmetro cujo tipo é uma classe, ele verifica as restrições de seus decoradores;
- linha 10: [transform: true]: a ação recebe uma verdadeira instância de [PersonDto], cujos campos foram convertidos ([@Type]);
- linha 11: [whitelist: true]: os parâmetros que não correspondem a nenhum campo da classe são removidos.
Uma requisição válida com um parâmetro ([pirate]) que não está declarado na classe:
| 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}
|
A idade de fato se tornou um número, e o parâmetro [pirate] desapareceu. Uma requisição inválida:
| 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}
|
O [ValidationPipe] rejeitou a requisição com um erro 400, cujo corpo (JSON) lista as mensagens de erro. A ação não foi executada. O mesmo resultado ocorre sem nenhum parâmetro:
| 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}
|
Esse comportamento é o esperado para um servidor JSON, consultado por um cliente [JavaScript] que exibe os erros à sua maneira. Para uma aplicação HTML, um JSON de erro não faz sentido: queremos reexibir o formulário com seus erros. O exemplo a seguir mostra como assumir o controle.
3.3. Exemplo 09: Validação feita pela ação
O Exemplo 09 não tem um [ValidationPipe] global. A própria ação converte e valida o modelo, usando os mesmos decoradores (o arquivo [person.dto.ts] é idêntico):
O arquivo [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 {
// sem ValidationPipe aqui: a action recebe os parâmetros BRUTOS e
// decide ela mesma o que fazer com os erros
@Get('action01')
async action01(@Query() raw: Record<string, string>): Promise<string> {
// 1. objeto bruto -> instância de PersonDto (conversões de @Type incluídas)
const person = plainToInstance(PersonDto, raw);
// 2. verificação das restrições (@IsNotEmpty, @Min...)
const errors = await validate(person);
// 3. uma página HTML nos dois casos: sem erro 400
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>`;
}
}
|
Vamos comentar este código:
- linha 11: a ação recebe os parâmetros brutos: um objeto cujos campos são todos strings;
- linha 13: [plainToInstance] ([class-transformer]) cria uma instância de [PersonDto] a partir do objeto bruto, aplicando as conversões ([@Type]);
- linha 15: [validate] ([class-validator]) verifica todas as restrições. Ele retorna um array de erros, que fica vazio se tudo estiver correto. Cada erro indica o campo problemático ([property]) e as mensagens das restrições violadas ([constraints]);
- linhas 17–18: sem erros — uma página de boas-vindas;
- linhas 20–23: caso contrário, uma página que lista os erros. Nos dois casos, a resposta é uma página HTML, com código de status 200.


Essa é a técnica que todos os formulários do estudo de caso usarão (veja o Exemplo 19).
3.4. Exemplo 10: Parâmetros múltiplos
Um mesmo parâmetro pode aparecer várias vezes em uma requisição: é o caso das caixas de seleção de um formulário ou de uma lista de seleção múltipla ([?color=red&color=green]).
O arquivo [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: o que o Express recebe
@Get('action01')
action01(@Query('color') color: string | string[]): object {
return { color, isAnArray: Array.isArray(color) };
}
// /arrays/action02?color=red: sempre um array graças a ChoiceDto
@Get('action02')
action02(@Query() choice: ChoiceDto): object {
return { colors: choice.color, count: choice.color.length };
}
}
|
A ação [action01] (linhas 7–10) mostra o que uma ação recebe:
| 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}
|
O tipo depende do número de valores: uma string para um único valor, um array para vários valores. Essa é uma armadilha comum. A classe [ChoiceDto] trata os dois casos como um array:
O arquivo [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 transforma os dois casos em um array
@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[];
}
|
- linha 7: [@Transform] ([class-transformer]) aplica uma função de conversão ao campo: um valor único é colocado em um array;
- linha 8: o campo deve ser um array...
- linha 9: ...com pelo menos um elemento...
- linha 10: ... e cada elemento ([each: true]) deve estar na lista.
| 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. Exemplo 11: Parâmetros de uma requisição POST
Um formulário HTML enviado pelo método POST coloca seus campos no corpo da requisição, e não na URL. O decorador [@Body] então substitui [@Query]:
O arquivo [src/post.controller.ts]:
| import { Body, Controller, Headers, Post } from '@nestjs/common';
import { PersonDto } from './person.dto';
@Controller('post')
export class PostController {
// o corpo da requisição, como está
@Post('action01')
action01(@Body() body: Record<string, unknown>, @Headers('content-type') type: string): object {
return { receivedType: type, body };
}
// um único campo do corpo
@Post('action02')
action02(@Body('name') name: string): string {
return `name = [${name}]`;
}
// o corpo, convertido e validado pela classe PersonDto
@Post('action03')
action03(@Body() person: PersonDto): object {
return { person, ageType: typeof person.age };
}
}
|
- linhas 7–10: [@Body()] injeta o corpo da requisição, já decodificado pelo [NestJS]. [@Headers('content-type')] injeta um cabeçalho da requisição: o tipo do corpo;
- linhas 13–16: [@Body('name')] injeta um único campo do corpo;
- linhas 19–22: como com [@Query], o corpo pode ser descrito por uma classe e validado pelo [ValidationPipe] global.
A opção [-d] do [curl] envia uma requisição POST com um corpo no formato de um formulário HTML ([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"}}
|
O mesmo corpo em formato JSON (é o que um cliente envia em [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}}
|
O [NestJS] decodifica os dois formatos. Observe que “age” é uma string no primeiro caso (um formulário HTML transporta apenas texto) e um número no segundo. As outras duas ações:
| 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}
|
O código 201 (Created) é o código padrão de um POST para o [NestJS]. Em uma aplicação HTML, uma ação POST responde com uma página (caso em que se acrescenta [@HttpCode(200)]) ou com um redirecionamento (veja o Exemplo 20).
3.6. Exemplo 12: Pipes e decoradores personalizados
Você pode escrever seus próprios pipes e decoradores de parâmetro. O estudo de caso os usa com moderação, mas entendê-los ajuda a entender os do [NestJS].
3.6.1. Um pipe: DateFrPipe
O arquivo [src/date-fr.pipe.ts]:
| import { BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
// transforma uma data francesa "23/09/2026" em uma data ISO "2026-09-23"
@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" tem o formato correto, mas não existe
if (new Date(`${iso}T00:00:00Z`).toISOString().slice(0, 10) !== iso) {
throw new BadRequestException(`the date [${value}] does not exist`);
}
return iso;
}
}
|
- linhas 4–5: um pipe é uma classe [@Injectable()] que implementa a interface [PipeTransform<input, output>];
- linha 6: seu método [transform] recebe o valor do parâmetro e retorna o valor transformado, que será recebido pela ação;
- linhas 7–9: um valor que não tem a forma [dd/mm/yyyy] dispara uma [BadRequestException] (400);
- linhas 13–15: uma data que está no formato correto, mas não existe (31/02/2026), também é rejeitada: [new Date] a “corrige” para 03/03/2026, o que é detectado.
3.6.2. Um decorador de parâmetro: @Language()
O arquivo [src/language.decorator.ts]:
| import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { Request } from 'express';
// @Language(): o idioma preferido do navegador, lido do cabeçalho
// "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';
});
|
- Linha 6: [createParamDecorator] cria um decorador de parâmetro, semelhante a [@Query] ou [@Body]. A função recebe o argumento do decorador ([@Language('fr')]) e o contexto de execução da requisição;
- linha 7: o contexto dá acesso à requisição do [Express];
- linhas 8–10: são retornadas as duas primeiras letras do cabeçalho [Accept-Language], que indica os idiomas preferidos do usuário.
3.6.3. O controller
O arquivo [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: um pipe personalizado
@Get('schedule')
schedule(@Query('day', DateFrPipe) day: string): string {
return `schedule for the day [${day}]`;
}
// /examples/hello: um decorador de parâmetro personalizado
@Get('hello')
hello(@Language('fr') language: string): string {
return language === 'en' ? 'Hello!' : 'Bonjour !';
}
// /examples/search?keyword=nest&admin=true: [admin] não é declarado
@Get('search')
search(@Query() search: SearchDto): object {
return search;
}
}
|
- linha 10: o pipe é usado como [ParseIntPipe];
- linha 16: o decorador é usado como [@Query];
- Linha 22: um modelo descrito por uma classe, desta vez usando a opção [forbidNonWhitelisted] do [ValidationPipe] (arquivo [main.ts] abaixo).
O arquivo [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, // os campos não declarados são removidos...
forbidNonWhitelisted: true, // ... ou, com esta opção, rejeitados (400)
}),
);
await app.listen(3000);
console.log('Server started on http://localhost:3000');
}
bootstrap();
|
Linha 11: Com [forbidNonWhitelisted: true], um parâmetro não declarado na classe deixa de ser suprimido silenciosamente; ele causa um erro 400.
Os resultados:
| 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}
|
(A opção [-H] do [curl] adiciona um cabeçalho à requisição)
3.6.4. Conclusão
O modelo da ação é gerado pelo [NestJS] a partir da requisição: parâmetros de rota ([@Param]), URL ([@Query]), corpo ([@Body]) e cabeçalhos ([@Headers]). Os pipes convertem e validam esses valores. Para uma aplicação HTML, geralmente é preferível validar o modelo você mesmo (exemplo 09), para poder reexibir o formulário. Esse é o tema do próximo capítulo.