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 por encima de este, aportando 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 los lectores de la versión [Angular] de este curso volverán a encontrar en el lado del cliente.

[NestJS] está pensado principalmente para generar respuestas JSON: de forma predeterminada, todo 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]:

  • 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;
  • 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;
  • proveedores (decorador @[Injectable]): un proveedor es una clase normal, normalmente encargada de la lógica de negocio o del acceso a datos, que [NestJS] puede crear y proporcionar automáticamente (es decir, “inyectar”) a cualquier controlador o servicio que la 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 llama 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, he aquí 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 con 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 de forma explícita; 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 del 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 proporcionará automáticamente a cualquier otra clase que la solicite en su constructor, sin tener que escribir nunca 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, por lo que la ruta “hello” responde directamente en /hello;
  • línea 7: el constructor declara un parámetro appService de tipo [AppService], precedido del 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 (una única instancia, compartida por toda la aplicación) y la proporciona aquí automáticamente: 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 que se puede probar 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() (en el caso de estudio usaremos @[Post]() 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, lo que la compone. Son posibles cuatro propiedades: 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 otros módulos de los que este depende) 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, se 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 es compartida por todos los componentes que la necesitan, un punto importante para entender 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 otros 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')
obtiene un segmento variable de la URL, por ejemplo /getDoctorById/:id
[@Body]()
obtiene el cuerpo JSON de una solicitud POST, deserializado en una clase
[@Injectable]()
declara un proveedor (servicio, DAO…)
[@Module]({...})
declara un módulo, un conjunto 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).