Skip to content

3. El modelo de la acción

Una acción necesita información enviada por el navegador: los parámetros de la URL ([?name=martin&age=42]), los campos de formulario y los parámetros de ruta. El curso original denomina toda esta información el modelo de la acción. Este capítulo muestra cómo [NestJS] se la proporciona a la acción, la convierte al tipo correcto y la valida.

3.1. Ejemplo 07: parámetros de la URL

El archivo [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: un parámetro es SIEMPRE una cadena
  @Get('action02')
  action02(@Query('age') age: number): string {
    return `age = [${age}], of type ${typeof age}`;
  }

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

  // /parameters/action04?page=2: un valor por defecto si falta el parámetro
  @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 los parámetros a la vez
  @Get('action05')
  action05(@Query() parameters: Record<string, string>): object {
    return parameters;
  }
}

Analicemos este código:

  • líneas 6–9: [@Query('name')] inyecta el valor del parámetro [name] de la URL (la parte que sigue a [?], llamada cadena de consulta o [query string]);
  • líneas 12–15: el parámetro [age] se declara de tipo [number]... pero este tipo es solo una declaración [TypeScript], que se elimina durante la compilación. Lo que recibimos es siempre una cadena, como lo muestra la ejecución;
  • líneas 18–21: [ParseIntPipe] es un pipe: un objeto que transforma (y valida) el valor de un parámetro antes de que llegue a la acción. Aquí, la cadena ['42'] se convierte en el número 42; una cadena no numérica provoca un error 400 (Bad Request), sin que se ejecute la acción;
  • líneas 24–27: los pipes se encadenan: [DefaultValuePipe(1)] reemplaza un parámetro ausente por 1 y luego [ParseIntPipe] lo convierte;
  • líneas 30–33: [@Query()], sin argumentos, inyecta un objeto que contiene todos los parámetros de la URL.

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

Las comillas alrededor de la URL son necesarias cuando contiene el carácter [&], que tiene un significado especial para la consola. Observe que:

  • un parámetro ausente se trata como [undefined];
  • un parámetro presente es una cadena, sea cual sea el tipo declarado;
  • un pipe sirve para convertir y validar un parámetro, y devuelve un código de estado 400 si el valor no es válido.

Image

3.2. Ejemplo 08: un modelo de acción descrito por una clase

Cuando una acción tiene varios parámetros, se describen mediante una clase, a menudo llamada [DTO] ([Data Transfer Object]). Cada campo de la clase tiene decoradores de validación proporcionados por la biblioteca [class-validator]. Estos equivalen a los atributos [[Required]], [[Range]]..., etc., de [ASP.NET MVC].

El archivo [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;
}

Analicemos este código:

  • línea 1: [@Type] proviene de la biblioteca [class-transformer], que convierte los datos recibidos;
  • línea 2: los decoradores de validación de [class-validator];
  • líneas 5–7: el nombre es obligatorio ([@IsNotEmpty]) y debe tener entre 2 y 20 caracteres ([@Length]). Cada decorador acepta un mensaje de error personalizado;
  • líneas 9–13: [@Type(() => Number)] exige que la cadena recibida se convierta en número antes de la validación: un entero ([@IsInt]) entre 0 y 150 ([@Min], [@Max]);
  • líneas 15–16: el título debe ser uno de los valores de una lista;
  • líneas 18–20: la dirección de correo electrónico es opcional ([@IsOptional]); si está presente, debe ser válida ([@IsEmail]).

El archivo [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,
    };
  }
}

línea 8: la acción recibe un [PersonDto]. La acción devuelve la persona recibida, el tipo de su edad, y verifica que sea efectivamente una instancia de la clase [PersonDto].

Para que se apliquen los decoradores de la clase, la validación debe habilitarse una vez por todas en [main.ts]:

El archivo [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);
  // validación automática de TODOS los modelos de acción descritos por una clase
  app.useGlobalPipes(
    new ValidationPipe({
      transform: true, // convierte las cadenas recibidas a los tipos declarados
      whitelist: true, // elimina los campos no declarados en la clase
    }),
  );
  await app.listen(3000);
  console.log('Server started on http://localhost:3000');
}

bootstrap();
  • líneas 8–13: un pipe global, [ValidationPipe], se aplica a todos los parámetros de todas las acciones. Para un parámetro cuyo tipo es una clase, verifica las restricciones de sus decoradores;
  • línea 10: [transform: true]: la acción recibe una verdadera instancia de [PersonDto], cuyos campos se han convertido ([@Type]);
  • línea 11: [whitelist: true]: los parámetros que no corresponden a ningún campo de la clase se eliminan.

Una solicitud válida con un parámetro ([pirate]) que no está declarado en la clase:

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}

La edad efectivamente se convirtió en número, y el parámetro [pirate] desapareció. Una consulta no vá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}

[ValidationPipe] rechazó la solicitud con un error 400, cuyo cuerpo (JSON) enumera los mensajes de error. La acción no se ejecutó. Se obtiene el mismo resultado sin ningún 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}

Este comportamiento es el esperado para un servidor JSON, consultado por un cliente [JavaScript] que muestra los errores a su manera. Para una aplicación HTML, un JSON de error no tiene sentido: queremos volver a mostrar el formulario con sus errores. El siguiente ejemplo muestra cómo tomar el control.

3.3. Ejemplo 09: validación realizada por la acción

El ejemplo 09 no tiene un [ValidationPipe] global. La propia acción convierte y valida el modelo, con los mismos decoradores (el archivo [person.dto.ts] es idéntico):

El archivo [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 {
  // aquí no hay ValidationPipe: la acción recibe los parámetros EN BRUTO y
  // decide por sí misma qué hacer con los errores
  @Get('action01')
  async action01(@Query() raw: Record<string, string>): Promise<string> {
    // 1. objeto en bruto -> instancia de PersonDto (conversiones de @Type incluidas)
    const person = plainToInstance(PersonDto, raw);
    // 2. verificación de las restricciones (@IsNotEmpty, @Min...)
    const errors = await validate(person);
    // 3. una página HTML en ambos casos: sin error 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>`;
  }
}

Comentemos este código:

  • línea 11: la acción recibe los parámetros sin procesar: un objeto cuyos campos son todos cadenas;
  • línea 13: [plainToInstance] ([class-transformer]) crea una instancia de [PersonDto] a partir del objeto sin procesar, aplicando las conversiones ([@Type]);
  • línea 15: [validate] ([class-validator]) verifica todas las restricciones. Devuelve un arreglo de errores, que está vacío si todo está bien. Cada error indica el campo problemático ([property]) y los mensajes de las restricciones infringidas ([constraints]);
  • líneas 17–18: sin errores, una página de bienvenida;
  • líneas 20–23: en caso contrario, una página que enumera los errores. En ambos casos, la respuesta es una página HTML, con código de estado 200.

Image

Image

Esta es la técnica que usarán todos los formularios del caso de estudio (véase el ejemplo 19).

3.4. Ejemplo 10: parámetros múltiples

Un mismo parámetro puede aparecer varias veces en una solicitud: es el caso de las casillas de verificación de un formulario o de una lista de selección múltiple ([?color=red&color=green]).

El archivo [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: lo que recibe Express
  @Get('action01')
  action01(@Query('color') color: string | string[]): object {
    return { color, isAnArray: Array.isArray(color) };
  }

  // /arrays/action02?color=red: siempre un arreglo gracias a ChoiceDto
  @Get('action02')
  action02(@Query() choice: ChoiceDto): object {
    return { colors: choice.color, count: choice.color.length };
  }
}

La acción [action01] (líneas 7–10) muestra lo que recibe una acción:

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}

El tipo depende del número de valores: una cadena para un único valor, un arreglo para varios valores. Esta es una trampa frecuente. La clase [ChoiceDto] maneja ambos casos como un arreglo:

El archivo [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 convierte ambos casos en un arreglo
  @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[];
}
  • línea 7: [@Transform] ([class-transformer]) aplica una función de conversión al campo: un valor único se coloca en un arreglo;
  • línea 8: el campo debe ser un arreglo...
  • línea 9: ...con al menos un elemento...
  • línea 10: ... y cada elemento ([each: true]) debe estar en la 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. Ejemplo 11: parámetros de una solicitud POST

Un formulario HTML enviado con el método POST coloca sus campos en el cuerpo de la solicitud, no en la URL. El decorador [@Body] reemplaza entonces a [@Query]:

El archivo [src/post.controller.ts]:

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

@Controller('post')
export class PostController {
  // el cuerpo de la solicitud, tal cual
  @Post('action01')
  action01(@Body() body: Record<string, unknown>, @Headers('content-type') type: string): object {
    return { receivedType: type, body };
  }

  // un solo campo del cuerpo
  @Post('action02')
  action02(@Body('name') name: string): string {
    return `name = [${name}]`;
  }

  // el cuerpo, convertido y validado por la clase PersonDto
  @Post('action03')
  action03(@Body() person: PersonDto): object {
    return { person, ageType: typeof person.age };
  }
}
  • líneas 7–10: [@Body()] inyecta el cuerpo de la solicitud, ya decodificado por [NestJS]. [@Headers('content-type')] inyecta un encabezado de la solicitud: el tipo del cuerpo;
  • líneas 13–16: [@Body('name')] inyecta un único campo del cuerpo;
  • líneas 19–22: como con [@Query], el cuerpo puede describirse mediante una clase, validada por el [ValidationPipe] global.

La opción [-d] de [curl] envía una solicitud POST con un cuerpo en formato de formulario 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"}}

El mismo cuerpo en formato JSON (esto es lo que envía un cliente [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] decodifica ambos formatos. Observe que “age” es una cadena en el primer caso (un formulario HTML solo transporta texto) y un número en el segundo. Las otras dos acciones:

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}

El código 201 (Created) es el código por defecto de un POST para [NestJS]. Para una aplicación HTML, una acción POST responde con una página (en cuyo caso se agrega [@HttpCode(200)]) o con una redirección (véase el ejemplo 20).

3.6. Ejemplo 12: pipes y decoradores personalizados

Es posible escribir pipes y decoradores de parámetros propios. El caso de estudio los usa con moderación, pero entenderlos ayuda a comprender los de [NestJS].

3.6.1. Un pipe: DateFrPipe

El archivo [src/date-fr.pipe.ts]:

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

// convierte una fecha francesa "23/09/2026" en una fecha 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" tiene el formato correcto, pero no existe
    if (new Date(`${iso}T00:00:00Z`).toISOString().slice(0, 10) !== iso) {
      throw new BadRequestException(`the date [${value}] does not exist`);
    }
    return iso;
  }
}
  • líneas 4–5: un pipe es una clase [@Injectable()] que implementa la interfaz [PipeTransform<input, output>];
  • línea 6: su método [transform] recibe el valor del parámetro y devuelve el valor transformado, que recibirá la acción;
  • líneas 7–9: un valor que no tiene la forma [dd/mm/yyyy] provoca una [BadRequestException] (400);
  • líneas 13–15: una fecha que tiene el formato correcto pero no existe (31/02/2026) también se rechaza: [new Date] la “corrige” a 03/03/2026, lo cual se detecta.

3.6.2. Un decorador de parámetro: @Language()

El archivo [src/language.decorator.ts]:

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

// @Language(): el idioma preferido del navegador, leído del encabezado
// "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';
});
  • Línea 6: [createParamDecorator] crea un decorador de parámetro, similar a [@Query] o [@Body]. La función recibe el argumento del decorador ([@Language('fr')]) y el contexto de ejecución de la consulta;
  • línea 7: el contexto da acceso a la solicitud [Express];
  • líneas 8–10: se devuelven las dos primeras letras del encabezado [Accept-Language], que indica los idiomas preferidos del usuario.

3.6.3. El controlador

El archivo [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: un pipe personalizado
  @Get('schedule')
  schedule(@Query('day', DateFrPipe) day: string): string {
    return `schedule for the day [${day}]`;
  }

  // /examples/hello: un 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] no está declarado
  @Get('search')
  search(@Query() search: SearchDto): object {
    return search;
  }
}
  • línea 10: el pipe se usa como [ParseIntPipe];
  • línea 16: el decorador se usa como [@Query];
  • Línea 22: un modelo descrito por una clase, esta vez con la opción [forbidNonWhitelisted] de [ValidationPipe] (archivo [main.ts] más abajo).

El archivo [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, // los campos no declarados se eliminan...
      forbidNonWhitelisted: true, // ... o, con esta opción, se rechazan (400)
    }),
  );
  await app.listen(3000);
  console.log('Server started on http://localhost:3000');
}

bootstrap();

Línea 11: con [forbidNonWhitelisted: true], un parámetro no declarado en la clase ya no se elimina silenciosamente; provoca un error 400.

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

(La opción [-H] de [curl] agrega un encabezado a la solicitud)

3.6.4. Conclusión

El modelo de la acción es generado por [NestJS] a partir de la solicitud: parámetros de ruta ([@Param]), URL ([@Query]), cuerpo ([@Body]) y encabezados ([@Headers]). Los pipes convierten y validan estos valores. Para una aplicación HTML, normalmente es preferible validar el modelo uno mismo (ejemplo 09) para poder volver a mostrar el formulario. Este es el tema del siguiente capítulo.