Frontend

Como criar um projeto com Nestjs

Aprenda passo a passo a criar um serviço usando o framework Nestjs com uma fácil implementação.

Com a evolução das tecnologias surgem novas ferramentas que nso auxiliam na construção de aplicações mais complexas e robustas. O aumento do uso de javascript no lado do servidor a partir do Runtime Nodejs nos permite criar serviços com esta linguagem. Ferramentas baseadas no Nodejs facilitam essas implementações e estão se tornando poderosos instrumentos de desenvolvimento. Uma delas é o Nestjs, um framework que combina conceitos dos paradigmas de programação, como:

  • Orientação a objetos
  • Programação funcional
  • Programação reativa

Nestjs é uma abstração dos frameworks nodejs express/fastify, para criação de um servidor HTTP de fácil implementação e com uma arquitetura baseada na injeção de dependências.

Por natureza usa typescript, mas pode ser configurado para usar somente javascript.

A estrutura para se implementar uma feature no Nestjs basicamente se divide em três estruturas bases:

  • Module: estrutura que tem a responsabilidade de injetar as dependências e expor providores pertencentes aquela funcionalidade. As dependências injetadas podem ser do tipo ela ser um module, provider ou controller.
  • Controller: estrutura que tem como responsabilidade receber e retornar requisições do cliente. É onde se cria os endpoints da aplicação.
  • Provider: estrutura que tem como responsabilidade prover dados ou realizar operações da funcionalidade que sejam utilizadas nas injeções de dependências, conforme a sua aplicação.

A ideia desse artigo não é entrar muito afundo nas estruturas e práticas que o framework utiliza, e sim ter uma base de como se implementar um serviço com essa ferramenta., Você pode encontrar mais informações neste link.

Exemplo na prática

Para exemplificar como criar uma estrutura, vamos criar uma aplicação bem básica para demonstrar como é simples de se implementar um serviço. Ele vai basicamente verificar o login de um usuário, baseado no diagrama abaixo:

Exemplo:

No exemplo acima temos a estrutura de comunicação entre dois módulos, dentro do primeiro módulo uma controller e um provider que se comunica com o provider do outro módulo.

Gerar arquivos

Para gerar essas estruturas Nestjs fornece um cli para gerar os arquivos com uma estrutura padrão da ferramenta, ao usar a cli ela já atualiza as dependências de cada estrutura gerada.
Obs: Os pré requisitos para usar essa cli é ter instalado na máquina o nodejs e npm.

Após a instalação dos pré requisitos, é preciso instalar globalmente a cli, basta rodar o comando no terminal:

npm install -g @nestjs/cli

Pronto agora já podemos gerar as estruturas padrões do Nestjs usando a cli.

Criando a estrutura

Para gerar a estrutura padrão do Nestjs, é preciso rodar o comando no terminal:

nest new login-example
cd login-example

A estrutura gerada já vem pronta para colocar a aplicação em funcionamento, e já tras algumas estruturas por padrão, no nosso exemplo não vamos usar elas, mas elas podem ser de proveito para alguma aplicação.
Uma dependência bem importante nessa estrutura é o rxjs, ela é usada para manipular as funcionalidades usando o paradigma de programação funcional.

Criação do módulo usuário

Após a criação da estrutura, vamos criar o primeiro módulo que é o de usuário, para isso vamos executar o comando:

nest g mo user

Esse comando deve ter gerado um diretório user e dentro já criado o arquivo user.module.ts:

import { Module } from '@nestjs/common';

@Module({})
export class UserModule {}

Agora todas as dependências que esse módulo precisar serão importadas dentro desse arquivo.

Criação do service de usuário

Para criar o service que vai prover os dados relacionados ao módulo user, executamos o comando:

nest g s user/services/user --flat

No comando acima o g é um alias para generate e o s para service, o que vem após é a localização do arquivo, nesse caso para organizar melhor colocamos eles na pasta services, o último alias –flat é para não gerar dentro da pasta services a pasta user.

Após rodar esse comando podemos observar que automaticamente o Nestjs atualizou o module e gerou o arquivo user.service.ts:

import { Module } from '@nestjs/common';
import { UserService } from './user.service';

@Module({
  providers: [UserService],
  exports: [UserService]
})
export class UserModule {}

No caso acima está diferente da atualização feita no arquivo, pois coloquei o exports para conseguirmos usar o UserService nos outros módulos.
Agora vamos criar o método que vai retornar se o usuário é válido, vamos deixar o código bem hard code, pois estamos somente exemplificando as estruturas do Nestjs.

Primeiramente criaremos a interface para usuário, na raiz do modulo user, criaremos uma pasta chamada interfaces e dentro dela o arquivo User:

export interface User {
  document: string;
  password: string;
}

Após isso vamos criar uma estrutura hard code para listagem de usuários, e o método para verificar usuário.

import { Injectable } from '@nestjs/common';
import { of } from 'rxjs';

import { User } from '../interfaces/user.interface';

const users: User[] = [
  {
    document: '12345678910',
    password: '123456',
  },
  {
    document: '98765432100',
    password: '123456',
  },
];

@Injectable()
export class UserService {
  verifyUser(user: User) {
    const isValid = users.some(
      ({ document, password }) =>
        document === user.document && password === user.password,
    );

    return of(isValid);
  }
}

O método acima busca em um array se existe o usuário, e retorna a função of que gera um Observable do tipo boolean.
Pronto, agora temos o módulo de usuário, provendo os dados que vão ser utilizados no módulo de login.

Criação do módulo e service login

Executar os comandos para criar o módulo e service:

nest g mo login

nest g s login/services/login --flat

Para usarmos o service de usuário que criamos, vamos fazer a importação no módulo de login.

import { Module } from '@nestjs/common';

import { UserModule } from '../user/user.module';
import { LoginService } from './services/login.service';

@Module({
  imports: [UserModule],
  providers: [LoginService],
})
export class LoginModule {}

Agora conseguimos usar o UserService dentro das estruturas do módulo de login, e é o que vamos fazer agora:

import { Injectable } from '@nestjs/common';

import { UserService } from '../../user/services/user.service';

@Injectable()
export class LoginService {
  constructor(private readonly userService: UserService) {}

  login(document: string, password: string) {
    return this.userService.verifyUser({ document, password });
  }
}

E agora a finalização, que é gerar a controller onde vai ser consumido o método criado no LoginService:

nest g co login/api/rest/login --flat

Dentro do arquivo gerado, vamos declarar o endpoint que vai ser consumido, esse endpoint é do tipo GET e vamos colocar os parâmetros por querySelector:

import { Controller, Get, Query } from '@nestjs/common';

import { LoginService } from '../../services/login.service';

@Controller('login')
export class LoginController {
  constructor(private readonly userService: LoginService) {}

  @Get('/')
  login(
    @Query('document') document: string,
    @Query('password') password: string,
  ) {
    return this.userService.login(document, password);
  }
}

Agora vamos rodar a aplicação e consumir o endpoint que criamos, para isso rodar o comando:

npm run start:dev

Acessar a url:

http://localhost:3000/login?document=12345678910&password=123456

Caso tudo tenha dado certo, estará retornando true ao acessar esse endpoint, e com isso temos um serviço rodando com uma implementação simples e rápida.

Para melhor entendimento das estruturas do Nestjs e rxjs, a documentação é bem completa e possuí um grau de entendimento bem fácil.

%d blogueiros gostam disto: