Gerenciar um aplicativo de grande escala pode ser tedioso, especialmente quando construído sem uma estrutura bem planejada e uma estratégia rigorosa de organização de código. Isso pode levar a desastres durante a manutenção e deve ser evitado a todo custo. Esse desastre é causado por mudanças feitas na base de código e novos recursos à medida que o projeto cresce em sua base de usuários.
Já o Nest.js foi criado para resolver problemas de estruturação e organização de código. Ele combina abordagens modernas e modulares com princípios de engenharia de software.
Nest.js utiliza TypeScript para verificação de tipos e oferece uma arquitetura de software pronta para construir e implantar aplicativos testáveis, escaláveis, com baixo acoplamento e fácil manutenção.
Neste artigo, vamos explorar o Nest.js e o que você pode construir com ele. Também vamos falar sobre os pontos positivos e negativos do framework para que você entenda por que as empresas o escolhem em relação a outros frameworks do Node.js. E, por fim, vamos mostrar como criar uma API de lista de tarefas com o Nest.js.
O que é Nest.js?
O Nest.js é um dos frameworks Node.js de crescimento mais rápido para construir aplicativos backend eficientes, escaláveis e de nível empresarial usando o Node.js. Ele é conhecido por produzir aplicativos altamente testáveis, de fácil manutenção e escaláveis utilizando JavaScript e TypeScript modernos.
Com mais de 46,6k estrelas e 5,4k forks no GitHub, e uma contagem semanal de downloads de até 700.000, o framework é uma escolha popular para desenvolver seu projeto backend com Node.js.
Nest.js é a solução perfeita para o seu próximo projeto se você precisa construir um aplicativo escalável, de fácil manutenção e de nível empresarial.
Na próxima seção, vamos explorar para que ele é usado e as diferentes empresas que utilizam o framework em produção.
Para que o Nest.js é usado?
O Nest.js é um framework do lado do servidor Node.js excelente para construir aplicativos backend altamente testáveis e de fácil manutenção. Você pode criar inúmeros tipos de aplicativos com o Nest.js; você está limitado apenas pelas funcionalidades que seus aplicativos necessitam.
Como o framework utiliza TypeScript, o Nest.js é especialmente popular entre equipes que desejam aproveitar o poder de verificação de tipos do TypeScript. Além disso, é simples de aprender e dominar, com uma poderosa interface de linha de comando (CLI) para impulsionar a produtividade e facilitar o desenvolvimento. Essa CLI poderosa facilita o início de qualquer projeto server-side e acompanhar sua conclusão.
Além disso, Nest.js mantém documentação detalhada, e sua comunidade de desenvolvedores e colaboradores é muito ativa e pronta para responder às questões em tempo real.
Esses motivos facilitam entender por que tantas empresas estão migrando para o Nest.js em vez de outros frameworks. Abaixo está uma lista de algumas marcas populares que utilizam o framework em produção.
Roche
A Roche é uma empresa multinacional de saúde que opera sob duas divisões, farmacêutica e diagnóstica. Esta empresa americana de biotecnologia usa a estrutura Nest.js em seu site principal para atender seus pacientes de forma confiável e para expandir ainda mais seus serviços.
Adidas
Adidas é a maior fabricante de roupas esportivas da Europa e a segunda maior do mundo. A Adidas é conhecida por projetar e fabricar calçados, roupas e acessórios. Seu alcance global e popularidade são o motivo pelo qual eles decidiram usar a estrutura altamente escalável do Nest.js para construir aplicativos em larga escala e eficientes para sua marca.
Decathlon
Decathlon é um varejista de produtos esportivos com mais de 1.500 lojas em 57 países. A Decathlon escolheu a Nest.js como backend para o seu aplicativo web, visando escalabilidade e manutenção da sua base de códigos.
Você pode encontrar uma lista de empresas, projetos e ferramentas adicionais construídas com o Nest.js no GitHub.
A seguir, discutiremos por que você e sua empresa devem escolher o Nest.js para o seu próximo projeto, fornecendo insights sobre por que outras pessoas já usam o framework e seus benefícios.
Por que escolher o Nest.js
A escolha de um framework depende do tipo de aplicativo que você está desenvolvendo, já que diferentes aplicativos requerem um conjunto diferente de ferramentas.
Aqui, listaremos diferentes razões para selecionar o Nest.js como sua framework Node.js para atualizar ou construir seu próximo projeto.
- Fácil aprendizado e domínio: O Nest.js é fácil de aprender e dominar, especialmente para desenvolvedores familiarizados com o mundo do Angular. Isso permite um processo de desenvolvimento rápido e eficiente, pois os membros da equipe podem se adaptar facilmente a novos princípios e estruturas de desenvolvimento.
- Excelente estrutura arquitetônica: A framework possui uma excelente estrutura arquitetônica para aplicativos empresariais, pronta para uso. Isso facilita a construção de aplicativos empresariais altamente escaláveis e de fácil manutenção.
- Ampla variedade de opções de construção: Com o Nest.js, você pode construir serviços backend que vão desde APIs RESTful, aplicativos GraphQL, aplicativos MVC, WebSockets, CLI e Cron jobs com facilidade. Algumas arquiteturas padrão já estão incorporadas no framework do Nest.js.
- Tecnologias modernas e testes unitários: O Nest.js utiliza tecnologias modernas como TypeScript, padrões arquiteturais robustos, excelente documentação e facilita os testes unitários. Isso permite a construção de aplicativos empresariais escaláveis e de fácil manutenção.
- Suporte para construção de grandes aplicativos: O Nest.js foi criado para construir aplicativos monolíticos e microsserviços de grande escala, em que a arquitetura já é tratada e você só precisa desenvolver a lógica do seu negócio.
- Suporte à comunidade e módulos: O Nest.js oferece suporte a uma grande comunidade e a diversos módulos desenvolvidos pela comunidade. Você pode escolher entre vários módulos suportados pelo Nest.js, como TypeORM, Mongoose, GraphQL, logging, validação, cache, WebSockets e muito mais, para construir qualquer recurso específico que você precise.
Agora, vamos explorar os prós e os contras do Nest.js. Isso ajudará a solidificar sua decisão de adotar o framework, à medida que discutimos os aspectos positivos e negativos.
Prós e contras do Nest.js
Aqui, vamos enumerar os prós e contras do Nest.js para uma melhor compreensão de por que ele é um framework tão popular no ecossistema do Node.js.
Os prós
Alguns dos benefícios de usar o Nest.js incluem:
- Poderoso, mas fácil de usar: O framework é amigável para os desenvolvedores trabalharem, a ponto de mesmo os recursos mais complexos e poderosos serem fáceis de usar. A equipe do Nest.js projetou o framework para que os desenvolvedores possam começar rapidamente e se concentrar exclusivamente na escrita da lógica de negócios, enquanto o framework cuida de outros aspectos importantes do desenvolvimento, como segurança.
- Sintaxe de estilo Angular (backend): Angular é um framework de frontend muito popular com uma concentração em arquitetura e estruturação. Nest.js atua como Angular para o backend, pois utiliza o estilo e a sintaxe do Angular para ajudar a estruturar o seu projeto empresarial.
- TypeScript: O Nest.js oferece suporte ao TypeScript logo de início, resolvendo problemas de desempenho e permitindo escrever rapidamente aplicativos de fácil manutenção, fornecendo erros e avisos de compilação. O TypeScript é bem integrado ao VSCode, proporcionando um ambiente de desenvolvimento acessível.
- Documentação completa: O Nest.js apresenta uma das melhores documentações para qualquer framework, o que é muito fácil de entender. Isso economiza tempo de depuração, permitindo que você consulte rapidamente a documentação e encontre a solução para o seu problema.
- Boa arquitetura e rápido desenvolvimento: O Nest.js economiza tempo ao construir seu aplicativo, seja criando seu primeiro MVP ou o aplicativo real, pois ele oferece uma estrutura e arquitetura sólidas para começar, melhorando assim seus processos de desenvolvimento.
Os contras
Existe um ditado famoso que diz: “Toda vantagem tem suas desvantagens” – e o Nest.js não é exceção. Então, vamos explorar as desvantagens do Nest.js.
- Difícil para iniciantes: O Nest.js pode ser um pouco complicado para desenvolvedores iniciantes que não têm experiência com Angular. Além disso, como nem todo desenvolvedor JavaScript utiliza TypeScript, o framework pode ser desafiador para esses desenvolvedores também. No entanto, assim como qualquer outra tecnologia, ele requer tempo e prática para dominar.
- Depuração trabalhosa: Por mais que o TypeScript tenha suas vantagens, ele também pode trazer algumas dificuldades na depuração, especialmente para desenvolvedores menos experientes no mundo do TypeScript.
Aí estão os prós e contras do Nest.js e como eles podem influenciar sua decisão na escolha deste framework.
A seguir, vamos praticar a construção de uma API RESTful com o Nest.js para solidificar o que aprendemos até agora. Continue lendo para aprender como desenvolver uma API de lista de tarefas que permitirá aos usuários criar e gerenciar suas próprias listas de tarefas.
Construa sua primeira API RESTful com o Nest.js
É hora de praticar tudo o que aprendemos sobre o Nest.js, construindo nossa primeira API RESTful para demonstrar o poder e a simplicidade que ele oferece.
Começaremos configurando o framework e instalando todas as ferramentas necessárias para colocá-lo em funcionamento.
1. Configurando o Nest.js
Primeiro, instalamos o Nest CLI para criar novos projetos com este comando:
npm i -g @nestjs/cliDepois disso, crie um novo projeto usando este comando abaixo:
nest new nest-todo-api
cd nest-todo-api
npm run start:devAgora que temos o Nest CLI instalado e nosso novo projeto criado com sucesso, vamos construir nossa API.
Abra o projeto em um editor de código da sua escolha. Se você acessar localhost:3000, deverá ser recebido com uma mensagem de boas-vindas mostrando que tudo funciona corretamente.
A seguir, vamos configurar um banco de dados MongoDB para conectar e gerenciar nossos dados de tarefas em todo o projeto.
Antes de prosseguirmos, vamos gerar todos os arquivos que precisaremos para criar a API com os seguintes comandos:
nest generate module todos
nest generate controller todos
nest generate service todos2. Configurando o MongoDB
A seguir, vamos instalar e configurar o MongoDB para funcionar com o projeto que criamos anteriormente.
Após instalar o MongoDB em sua máquina local, execute o seguinte comando para instalar a biblioteca Mongoose em nosso projeto recém-criado:
npm install --save @nestjs/mongoose mongooseIsso é tudo que você precisa fazer.
Em seguida, vamos gerar os arquivos e importar o Mongoose para se comunicar com o projeto e o MongoDB.
Vamos importar o Mongoose em nosso arquivo de módulo do aplicativo antes de gerar os demais arquivos necessários:
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { MongooseModule } from '@nestjs/mongoose';
import { TodosModule } from './todos/todos.module';
@Module({
imports: [MongooseModule.forRoot('mongodb://localhost/todos), TodosModule],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}3. Construindo o Esquema
A seguir, vamos construir o esquema do banco de dados para o nosso banco de dados. Este esquema irá especificar como os dados serão representados em nosso banco de dados.
Vamos defini-lo em nosso arquivo todos.schema.ts:
import * as mongoose from 'mongoose';
export const ItemSchema = new mongoose.Schema({
title: String,
is_completed: Boolean,
description: String,
});4. Definindo interfaces
Agora, vamos criar uma interface para verificação de tipos.
Vamos defini-la em nosso arquivo interfaces/todo.interface.ts:
import { Document } from 'mongoose';
export interface Item extends Document {
id?: string;
title: string;
description?: string;
is_completed: boolean;
}5. Criando o DTO
Finalmente, vamos construir um DTO (Data Transfer Object) que define como os dados serão enviados ou passados de objeto para objeto através da rede.
É uma classe básica com a mesma propriedade do nosso esquema:
// ./dto/create-todo.ts
export class CreateItemDto {
readonly title: string;
readonly description: string;
readonly is_completed: boolean;
}6. Configurando o Model/Service
O arquivo do serviço é responsável pela interação e comunicação com o banco de dados MongoDB. Ele é usado para criar, recuperar, atualizar e excluir registros do esquema todos que criamos anteriormente.
Abra seu arquivo de serviços e adicione os seguintes códigos:
import { Injectable } from '@nestjs/common';
import { Todo } from './interfaces/todo.interface';
import { Model } from 'mongoose';
import { InjectModel } from '@nestjs/mongoose';
import { CreateTodoDto } from './dto/create-todo.dto';
@Injectable()
export class ItemsService {
constructor(@InjectModel('Todo') private readonly todoModel: Model) {}
async findAll(): Promise<Todo[]> {
return await this.todoModel.find();
}
async findOne(id: string): Promise {
return await this.todoModel.findOne({ _id: id });
}
async create(item: CreateItemDto): Promise {
const newTodo = new this.todoModel(item);
return await newTodo.save();
}
async delete(id: string): Promise {
return await this.todoModel.findByIdAndRemove(id);
}
async update(id: string, todo: CreateTodoDto): Promise {
return await this.todoModel.findByIdAndUpdate(id, todo, { new: true });
}
}O snippet de código acima representa um aplicativo CRUD (criar, ler, atualizar, excluir) em nossa API usando o modelo Mongoose para fornecer acesso ao nosso banco de dados MongoDB subjacente.
A seguir, criaremos nosso arquivo controlador para lidar com toda a lógica e nos comunicarmos com o serviço que criamos acima.
7. Configurando os controladores
O controlador é responsável por lidar com as requisições recebidas e enviar respostas de volta ao cliente.
Vamos definir nosso controlador Todo e colar no seguinte snippet de código:
import {
Controller,
Get,
Post,
Put,
Delete,
Body,
Param,
} from '@nestjs/common';
import { CreateTodoDto } from './dto/create-todo.dto';
import { TodosService } from './todos.service';
import { Todo } from './interfaces/todo.interface';
@Controller('items')
export class ItemsController {
constructor(private readonly todosService: TodosService) {}
@Get()
findAll(): Promise<Todo[]> {
return this.todosService.findAll();
}
@Get(':id')
findOne(@Param('id') id): Promise {
return this.todosService.findOne(id);
}
@Post()
create(@Body() createTodoDto: CreateTodoDto): Promise {
return this.todosService.create(createTodoDto);
}
@Delete(':id')
delete(@Param('id') id): Promise {
return this.todosService.delete(id);
}
@Put(':id')
update(@Body() updateTodoDto: CreateTodoDto, @Param('id') id): Promise {
return this.todosService.update(id, updateTodoDto);
}
}O framework usa anotações para lidar com muitas funcionalidades nos bastidores – por exemplo, para lidar com o sistema de roteamento do framework, fornecendo diferentes anotações correspondentes a cada rota (@Put(), @Delete(), @Post(), @Get()) para os métodos Put, Delete, Post, e Get de uma API RESTful, respectivamente.
8. Testando a API com o Postman
Por fim, vamos testar nossa API recém-criada com o Postman. Precisamos iniciar o servidor de desenvolvimento para garantir que tudo esteja funcionando corretamente antes de implantar em um servidor de produção.
npm run start:devVocê pode baixar e executar o Postman para testar sua API RESTful.
Resumo
Nest.js é um poderoso framework Node.js e o framework TypeScript mais popular disponível atualmente.
Ele fornece à equipe de engenharia uma arquitetura de desenvolvimento padrão e as melhores práticas da indústria. Com ele, os desenvolvedores podem abstrair processos de engenharia repetitivos para se concentrarem exclusivamente no desenvolvimento da lógica de negócios.
Essas vantagens são o que motivam marcas populares como Adidas, Roche e outras a utilizarem o framework em seus aplicativos empresariais de produção.
Neste artigo, estabelecemos uma base sólida para o Nest.js e explicamos por que você e sua empresa devem considerar a migração para ele. Além disso, construímos uma API RESTful simples de lista de tarefas para demonstrar na prática as incríveis capacidades do framework.
Agora cabe a você decidir se o Nest.js é o framework perfeito para você.
