🥃 👩🏽‍🍳 🗨️ Conheça NestJS 🤳🏾 🕵🏼 🧑🏽

A tradução do artigo foi preparado antes do lançamento do desenvolvedor Node.js curso .

Os desenvolvedores modernos têm muitas alternativas quando se trata de criar serviços da Web e outros aplicativos de servidor. O nó tornou-se uma opção extremamente popular; no entanto, muitos programadores preferem uma linguagem mais robusta que o JavaScript, especialmente aqueles que vêm de linguagens orientadas a objetos modernas, como C #, C ++ ou Java. Se o TypeScript se adequar perfeitamente ao NodeJS , a estrutura do NestJS o levará a um nível totalmente novo, fornecendo ferramentas modernas para o desenvolvedor back-end para criar aplicativos duráveis e de alto desempenho usando componentes, provedores, módulos e outras abstrações úteis de alto nível.

Neste artigo, veremos o processo de criação de um servidor de API simples no NestJS para processar o cenário básico do aplicativo: criação, armazenamento e recuperação de uma lista de produtos de supermercado.
Se você deseja se familiarizar com o código fonte do projeto, pode encontrá-lo aqui .

Criação de projeto

Para trabalhar com o Nest, você precisa de um ambiente Node. Se você ainda não o possui, acesse o site deles e faça o download.

A instalação da estrutura é bastante simples:

$ npm i -g @nestjs/cli

Este projeto foi criado usando a CLI do Nest depois de executar o seguinte comando:

$ nest new nest-js-example

Essa equipe criará um projeto Nest completamente novo com os arquivos de configuração, estrutura de pastas e modelo de servidor necessários.

Ponto de entrada do aplicativo

O arquivo principal que configura e inicia o servidor é 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 arquivo importa a classe NestFactory , que é usada para criar o aplicativo, e o arquivo principal do AppModule (que conheceremos em breve) e, em seguida, baixa o aplicativo, instancia-o e escuta na porta 3000.

Módulo de aplicativo

O arquivo no qual os componentes do aplicativo são declarados é chamado 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 é o arquivo no qual os outros componentes são importados e declarados no Módulo, que é importado no arquivo anterior ( main.ts ). As ferramentas da CLI do Nest atualizarão automaticamente esse arquivo, conforme necessário, quando instruídas a criar um novo componente. Aqui, o controlador e o serviço dos itens são importados e adicionados ao módulo.

Controlador de itens

O próximo arquivo que iremos revisar é 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 arquivo define o controlador para criar itens e obter uma lista dos itens criados anteriormente. Vários componentes principais são importados aqui:

CreateItemDto : um objeto de transferência de dados que define como os dados do item serão enviados pela rede (isto é, uma estrutura de dados JSON);
ItemsService: Provedor que lida com a manipulação ou armazenamento de dados do Item ;
Item : Uma interface que define a estrutura de dados interna para o Item ;

O decorador @Controller('items')informa à estrutura que essa classe servirá o terminal REST / items , e o construtor ItemsController usa uma instância do ItemsService , que é usada internamente para servir a dois métodos HTTP:

POST / items (cria um novo item a partir de uma solicitação JSON);
GET / items (obtendo uma lista dos itens criados anteriormente).

As solicitações para esses dois métodos são processadas pelos métodos create e FindAll, que são vinculados aos métodos HTTP correspondentes usando os decoradores @Post()e @Get(). Métodos adicionais também podem ser suportados por decoradores de maneira semelhante, por exemplo, @Put()ou @Delete()etc.

Interfaces de objeto de item

Em seguida, trataremos de dois arquivos que definem interfaces para armazenar itens , um para uso interno, como verificação de tipo no tempo de compilação ( Item ) e uma interface externa para determinar a estrutura esperada do JSON de entrada ( 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;
}

A interface Item define três propriedades de um produto comum da loja: nome, descrição e preço. Isso garante que não haja confusão na arquitetura do aplicativo em relação ao que é um item e a quais propriedades ele possui.

A classe CreateItemDto reflete as propriedades do Item , decorando cada propriedade @IsNotEmpty()para garantir que todas essas propriedades sejam solicitadas pelo terminal da API REST.

Todas as propriedades de ambas as classes são fortemente tipadas, o que é uma das principais vantagens do TypeScript (daí o nome). À primeira vista, isso aumenta o nível de entendimento do contexto e reduz significativamente o tempo de desenvolvimento quando usado corretamente com ferramentas de análise de código (como IntelliSense no VSCode). Isto é especialmente verdadeiro para projetos grandes com centenas ou mesmo milhares de classes e interfaces diferentes. Para aqueles que não têm uma memória fotográfica perfeita com capacidade infinita (por exemplo, para mim), é muito mais fácil do que tentar lembrar milhares de detalhes específicos.

Serviço de itens

O mais recente é um serviço para criar e receber 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;
    }
}

A classe ItemsService define uma matriz simples de objetos Item que servirão como armazenamento de dados na memória para o nosso projeto de amostra. Dois métodos que escrevem e lêem neste repositório são:

create (salva Item na lista e retorna seu ID);
findAll (retorna uma lista de objetos Item criados anteriormente ).

Teste

Para iniciar o servidor, use o comando npm run start padrão . Quando o aplicativo é iniciado, ele pode ser testado enviando solicitações HTTP via CURL :

$ curl -X POST localhost:3000/items -d '{"name":"trinket", "description":"whatever", "price": 42.0}'

A execução desse comando retornará uma resposta JSON com o ID gerado pelo item . Para mostrar uma lista de itens que já foram criados, use:

$ curl localhost:3000/items

A solicitação GET para / itens acima retornará uma resposta JSON com informações sobre os itens que já estão na memória. A resposta deve ser algo como isto:

[{"{\"name\":\"trinket\", \"description\":\"whatever\", \"price\": 42.0}":""}]

Conclusão

O NestJS é uma solução relativamente nova no campo do desenvolvimento de back-end, com um grande conjunto de funções para criar e implantar rapidamente serviços corporativos que atendem aos requisitos dos clientes de aplicativos modernos e aderem aos princípios do SOLID e à aplicação de doze fatores .

Para saber mais, visite o site da NestJS .
Obrigado por ler o meu artigo. Feliz codificação!

Conheça NestJS