Se preparó una traducción del artículo antes del lanzamiento del curso Node.js Developer .
Los desarrolladores modernos tienen muchas alternativas a la hora de crear servicios web y otras aplicaciones de servidor. Node se ha convertido en una opción extremadamente popular, sin embargo, muchos programadores prefieren un lenguaje más robusto que JavaScript, especialmente aquellos que provienen de lenguajes modernos orientados a objetos, como C #, C ++ o Java. Si TypeScript se adapta bien a NodeJS , el marco NestJS lo lleva a un nivel completamente nuevo, proporcionando herramientas modernas para que el desarrollador de back-end cree aplicaciones duraderas y de alto rendimiento utilizando componentes, proveedores, módulos y otras abstracciones útiles de alto nivel.En este artículo, veremos el proceso de creación de un servidor API simple en NestJS para procesar el escenario básico de la aplicación: crear, almacenar y recuperar una lista de productos de supermercados.Si desea familiarizarse con el código fuente del proyecto, puede encontrarlo aquí .Creación de proyectos
Para trabajar con Nest, necesita un entorno Node. Si aún no lo tiene, vaya a su sitio web y descárguelo.Instalar el marco es bastante simple:$ npm i -g @nestjs/cli
Este proyecto fue creado usando la CLI de Nest después de ejecutar el siguiente comando:$ nest new nest-js-example
Dicho equipo creará un proyecto Nest completamente nuevo con los archivos de configuración, estructura de carpetas y plantilla de servidor necesarios.Punto de entrada de la aplicación
El archivo principal que configura e inicia el servidor es src/main.ts:import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
}
bootstrap();
Este archivo importa la clase NestFactory , que se usa para crear la aplicación, y el archivo AppModule principal (que pronto veremos), y luego descarga la aplicación, la instancia y escucha en el puerto 3000.Módulo de aplicación
El archivo en el que se declaran los componentes de la aplicación se llama src/app.module.ts:import { Module } from '@nestjs/common';
import { ItemsController } from './items/items.controller';
import { ItemsService } from './items/items.service';
@Module({
imports: [],
controllers: [ ItemsController ],
providers: [ ItemsService ],
})
export class AppModule {}
Este es el archivo donde los otros componentes se importan y declaran en el Módulo, que se importa en el archivo anterior ( main.ts ). Las herramientas Nest CLI actualizarán automáticamente este archivo según sea necesario cuando se les indique que creen un nuevo componente. Aquí, el controlador y el servicio para los artículos se importan y se agregan al módulo.Controlador de artículos
El siguiente archivo que revisaremos es src/items/items.controller.ts:import { Controller, Req, Get, Post, Body } from '@nestjs/common'
import { CreateItemDto } from './dto/create-item.dto'
import { ItemsService } from './items.service'
import { Item } from './items.interface'
@Controller('items')
export class ItemsController {
constructor(private readonly itemsService: ItemsService) {}
@Post()
create(@Body() data: CreateItemDto): Object {
return this.itemsService.create(data)
}
@Get()
findAll(): Array<Item> {
return this.itemsService.findAll()
}
}
Este archivo define el controlador para crear elementos y obtener una lista de los creados anteriormente. Aquí se importan varios componentes clave:- CreateItemDto : un objeto de transferencia de datos que define cómo se enviarán los datos del artículo a través de la red (es decir, esta es una estructura de datos JSON);
- ItemsService: proveedor que maneja la manipulación o el almacenamiento de datos del artículo ;
- Artículo : una interfaz que define la estructura de datos interna para el Artículo ;
El decorador @Controller('items')le dice al marco que esta clase servirá el punto final REST / items , y el constructor ItemsController toma una instancia de ItemsService , que se usa internamente para servir dos métodos HTTP:- POST / items (crea un nuevo elemento a partir de una solicitud JSON);
- GET / items (obtener una lista de elementos creados previamente).
Las solicitudes para estos dos métodos son procesadas por los métodos create y FindAll, que están vinculados a los métodos HTTP correspondientes utilizando los decoradores @Post()y @Get(). Los decoradores también pueden admitir métodos adicionales de manera similar, por ejemplo, @Put()o @Delete(), etc.Elemento Interfaces de objeto
A continuación, trataremos con dos archivos que definen interfaces para almacenar elementos , uno para uso interno, como la verificación de tipos en tiempo de compilación ( Elemento ) y una interfaz externa para determinar la estructura esperada de JSON entrante ( CreateItemDto):export interface Item {
name: string,
description: string,
price: number
}
export class CreateItemDto {
@IsNotEmpty()
readonly name: string;
@IsNotEmpty()
readonly description: string;
@IsNotEmpty()
readonly price: number;
}
La interfaz del artículo define tres propiedades de un producto de la tienda normal: nombre, descripción y precio. Esto asegura que no haya confusión en la arquitectura de la aplicación con respecto a qué es un elemento y qué propiedades tiene.La clase CreateItemDto refleja las propiedades del elemento , decorando cada propiedad @IsNotEmpty()para garantizar que todas las propiedades sean solicitadas por el punto final de la API REST.Todas las propiedades de ambas clases están fuertemente tipadas, que es una de las principales ventajas de TypeScript (de ahí el nombre). A primera vista, esto aumenta el nivel de comprensión del contexto y reduce significativamente el tiempo de desarrollo si se usa correctamente con herramientas de análisis de código (como IntelliSense en VSCode). Esto es especialmente cierto para grandes proyectos con cientos o incluso miles de clases e interfaces diferentes. Para aquellos que no tienen una memoria fotográfica perfecta con capacidad infinita (por ejemplo, para mí), es mucho más fácil que tratar de recordar miles de detalles específicos.Servicio de artículos
El más reciente es un servicio para crear y recibir items: items.service.dart:import { Injectable } from '@nestjs/common'
import { Item } from './items.interface'
@Injectable()
export class ItemsService {
private items: Array<Item> = []
create(item: Item): Object {
this.items.push(item)
return { id: this.items.length.toString() }
}
findAll(): Array<Item> {
return this.items;
}
}
La clase ItemsService define una matriz simple de objetos Item que servirá como almacén de datos en memoria para nuestro proyecto de muestra. Dos métodos que escriben y leen desde este repositorio son:- crear (guarda el elemento en la lista y devuelve su id);
- findAll (devuelve una lista de objetos Item creados previamente ).
Pruebas
Para iniciar el servidor, use el comando npm run start estándar . Cuando se inicia la aplicación, se puede probar enviando solicitudes HTTP a través de CURL :$ curl -X POST localhost:3000/items -d '{"name":"trinket", "description":"whatever", "price": 42.0}'
La ejecución de este comando devolverá una respuesta JSON con la identificación generada por el elemento . Para mostrar una lista de elementos que ya se han creado, use:$ curl localhost:3000/items
La solicitud GET a / elementos anteriores devolverá una respuesta JSON con información sobre los elementos que ya están en la memoria. La respuesta debería verse así:[{"{\"name\":\"trinket\", \"description\":\"whatever\", \"price\": 42.0}":""}]
Conclusión
NestJS es una solución relativamente nueva en el campo del desarrollo de backend, con un amplio conjunto de funciones para construir e implementar rápidamente servicios corporativos que cumplan con los requisitos de los clientes de aplicaciones modernas y cumplan con los principios de SOLID y la aplicación de doce factores .Para obtener más información, visite el sitio web de NestJS .Gracias por leer mi artículo. ¡Feliz codificación!