Skip to content

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

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.

Image

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

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

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
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}

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.

Image

Image

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

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

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
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}}

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
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}

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

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