Skip to content

3. Capítulo 2 - Introducción a [NestJS]

3.1. Fuentes

Este capítulo se basa en las siguientes fuentes:

3.2. El papel de [NestJS] en una aplicación web

[NestJS] es un framework de Node.js escrito en TypeScript, diseñado para construir el lado del servidor de una aplicación web, casi siempre una API REST (JSON). No reinventa el manejo del protocolo HTTP: de forma predeterminada, se apoya en Express, un framework de Node.js más rudimentario encargado de recibir las solicitudes HTTP sin procesar y de responderlas. [NestJS] se sitúa sobre esa base y aporta una organización del código que ni Node.js ni Express imponen por sí solos: división en módulos, controladores y servicios; inyección de dependencias; decoradores…

Su arquitectura se inspira en gran medida en [Angular] (decoradores, módulos, inyección de dependencias), una similitud que nos será muy útil en el capítulo 4, cuando encontremos exactamente los mismos conceptos del lado del cliente.

[NestJS] está diseñado principalmente para generar respuestas JSON: de forma predeterminada, lo que devuelve un método de un controlador se convierte automáticamente a JSON y se envía al cliente, sin ninguna configuración especial.

3.3. El modelo de desarrollo de [NestJS]

Tres conceptos forman la estructura de una aplicación [NestJS]:

  • los módulos (decorador @[Module]): un módulo agrupa un conjunto de funcionalidades relacionadas: declara qué controladores y servicios le pertenecen, qué otros módulos necesita y qué pone a disposición de los demás. Una aplicación [NestJS] siempre parte de un módulo raíz, [AppModule], que ensambla todos los demás módulos del proyecto;
  • los controladores (decorador @[Controller]): un controlador es el punto de entrada de la aplicación: una clase en la que cada método recibe las solicitudes HTTP correspondientes a una URL específica y devuelve una respuesta al cliente;
  • los proveedores (decorador @[Injectable]): un proveedor es una clase común, normalmente responsable de la lógica de negocio o del acceso a datos, que [NestJS] puede crear y suministrar automáticamente (es decir, «inyectar») a cualquier controlador o servicio que lo necesite.

En la práctica, una clase que necesita un proveedor simplemente lo declara como parámetro de su constructor: [NestJS] crea la instancia necesaria y la pasa automáticamente, sin que usted tenga que escribir new: esto se denomina inyección de dependencias por constructor, una práctica que se usa casi siempre en NestJS.

3.4. Un primer ejemplo: el miniproyecto «hello»

Para reforzar estos tres conceptos, aquí hay un proyecto [NestJS] muy pequeño, independiente del caso de estudio (una sola ruta /hello), que puede crear con (escriba estos comandos en una carpeta vacía que haya abierto en VSCode [File/Open Folder]. Estos comandos crean una carpeta llamada [hello-nest]):

1
2
3
4
npm install -g [@nestjs/cli]
nest new hello-nest
cd hello-nest
npm run start:dev

Image

Este comando genera un proyecto que contiene los siguientes archivos esenciales: [src/main.ts], src/app.module.ts, src/app.controller.ts, src/app.service.ts. Estos cuatro archivos bastan para ilustrar la arquitectura de una aplicación [NestJS]: un punto de entrada ([main.ts]), un módulo raíz (app.module.ts), un controlador (app.controller.ts) y un servicio (app.service.ts).

3.4.1. El servicio


// src/app.service.ts
import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
  getHello(): string {
    return 'Hello World!';
  }
}
  • línea 2: cada elemento utilizado se importa explícitamente; aquí, [Injectable] se importa desde [@nestjs/common], el módulo que contiene la mayoría de los decoradores y clases de utilidad de [NestJS];
  • línea 4: Un decorador es una anotación colocada inmediatamente encima de una clase, un método o un parámetro de TypeScript (precedida por el símbolo @), que modifica o mejora su comportamiento sin alterar su código; es el mecanismo en el que se basa prácticamente todo el vocabulario de NestJS. @[Injectable]() marca esta clase como un proveedor: [NestJS] la creará por sí mismo y la suministrará automáticamente a cualquier otra clase que la solicite en su constructor, sin que haya que escribir new [AppService]();
  • Línea 6: : string declara el tipo de retorno, una característica propia de TypeScript que no existe en JavaScript.

3.4.2. El controlador

// src/app.controller.ts
import { Controller, Get } from '@nestjs/common';
import { AppService } from './app.service.js';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) { }

  @Get('hello')
  getHello(): string {
    return this.appService.getHello();
  }
}
  • Línea 5: @Controller() decora la clase siguiente para convertirla en un controlador: NestJS le enviará las solicitudes HTTP correspondientes a sus rutas. El argumento entre paréntesis es un prefijo opcional que se agrega al comienzo de todas las rutas de la clase; aquí está vacío: la ruta «hello» responde, por lo tanto, directamente en /hello;
  • Línea 7: El constructor declara un parámetro llamado appService de tipo [AppService], precedido por el modificador de TypeScript private readonly, que, en una sola línea, lo declara Y lo registra como propiedad de la instancia (this.appService). [NestJS] determina que el controlador necesita un [AppService], crea una instancia de este (una única instancia, compartida por toda la aplicación) y la suministra automáticamente aquí: es la inyección de dependencias por constructor mencionada antes;
  • línea 9: [@Get]('hello') asocia el método siguiente con la ruta HTTP GET /hello: este decorador hace que la acción sea accesible en la dirección de prueba http://localhost:3000/hello una vez iniciado el servidor. Otros decoradores cumplen la misma función para los demás verbos HTTP: @[Post](), @Put(), @Delete(), @Patch() (usaremos @[Post]() en el caso de estudio, para /addAppointment y /deleteAppointment). Observe que, en la línea 10, el nombre del método [getHello] es irrelevante. Podría ser cualquier nombre;
  • Línea 11: El controlador delega el trabajo en el servicio inyectado en lugar de programar él mismo la respuesta: sigue siendo una simple capa de enrutamiento, mientras que la lógica de negocio reside en el servicio, un principio que veremos a mayor escala en el caso de estudio del capítulo 3.

3.4.3. El módulo

// src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller.js';
import { AppService } from './app.service.js';

@Module({
  imports: [],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}
  • línea 6: @[Module]({...}) decora la clase siguiente para convertirla en un módulo: agrupa una parte coherente de la aplicación y declara, en el objeto pasado como argumento, qué la compone. Hay cuatro propiedades posibles: controllers (los controladores que expone este módulo), providers (los servicios que provee este módulo, disponibles para inyección dentro del módulo), imports (los demás módulos de los que depende este) y exports (los proveedores que este módulo pone a disposición de los módulos que lo importan);
  • Sin la línea `controllers: [AppController]`, `[NestJS]` ignoraría este controlador y sus rutas no responderían a ninguna solicitud; sin `providers: [AppService]`, la inyección de dependencias del controlador fallaría al iniciar.

3.4.4. Ejecución

Con VSCode, en una terminal abierta en la raíz de la carpeta [hello-nest], escriba el siguiente comando:

npm run start:dev

Al abrir http://localhost:3000/hello en un navegador, obtiene la siguiente respuesta:

Image

3.5. Proveedores e inyección de dependencias

Una clase anotada con @[Injectable]() es un proveedor: [NestJS] sabe cómo instanciarla e inyectarla automáticamente donde se solicite en un constructor, siempre que aparezca en el arreglo providers de un módulo. De forma predeterminada, un proveedor de [NestJS] es un singleton: se crea una sola instancia al iniciar la aplicación y esa misma instancia se comparte entre todos los componentes que la necesitan, un punto importante para comprender el papel del servicio [ApplicationModelService] en el caso de estudio (capítulo 3), que almacena datos en caché al iniciar el servidor.

3.6. Los demás decoradores que aparecerán en el caso de estudio

Decorador
Función
[@Get](url), [@Post](url)
asocia un método de controlador con una ruta HTTP
[@Param]('x')
recupera un segmento variable de la URL, p. ej., /getDoctorById/:id
[@Body]()
recupera el cuerpo JSON de una solicitud POST, deserializado en una clase
[@Injectable]()
declara un proveedor (servicio, DAO…)
[@Module]({...})
declara un módulo, un ensamblaje de controladores y proveedores

Estos decoradores se explicarán en detalle, uno por uno, en el lugar exacto donde aparecen en el código del servidor [RdvMedecins] (capítulo 3).