Nesse artigo iremos criar uma aplicação REST do zero usando o framework NestJS, utilizando a linguagem Typescript, rodando o Fastify e o TypeORM para manipulação no banco de dados.
\nIremos usar uma abordagem arquitetural conhecida como Arquitetura Hexagonal que facilita muito o trabalho de desenvolvimento, deixando a aplicação plugável, independente de frameworks e bancos de dados.
\nO NestJS é um framework construído em Typescript o que trás elementos de programação orientada a objetos OOP e programação funcional FP, inicialmente ele roda com Express mas nesse artigo será mostrado como é fácil alterar para o Fastify.
\nPara iniciarmos o projeto podemos usar o cli utilitário do NestJS para isso:
\nnpm i -g @nestjs/cliE com isso temos o cli do NestJS instalado de forma global no seu computador. E para criar um projeto novo pode ser usado o comando a seguir:
\nnest new cadastro-apiNo comando acima é utilizado o comando nest seguido de new e o nome do projeto que nesse caso será cadastro-api.
\nEsse projeto será uma aplicação para cadastro de livros e seus autores, onde um autor pode ter vários livros. Mas será exposta somente a inclusão de livros e a aplicação terá inteligência o suficiente para cadastrar o autor caso não exista.
\nCom isso o projeto está pronto porém ele por padrão vem com o Express e será necessário alterar para o Fastify. O Fastify que é inspirado tanto no Hapi quanto no Express é um framework web com foco na produtividade e performance, para adicionar ele no projeto basta executar o comando abaixo:
\nnpm i --save @nestjs/platform-fastifyE com isso já é instalado o Fastify com os módulos para utilização com o NestJS.
\nE por fim será adicionado o TypeORM que faz a integração entre a aplicação e o banco de dados, para esse exemplo usaremos o banco de dados MySQL e para instalar usaremos o comando a seguir:
\nnpm install --save @nestjs/typeorm typeorm mysqlE agora temos o projeto com as dependências necessárias para começarmos a parte de construção da aplicação com base na Arquitetura Hexagonal.
\nNo modelo de Arquitetura Hexagonal é importante definir primeiramente a camada de domínio pois é partir dela que toda aplicação cresce, é importante também salientar que nesse modelo a camada de domínio não tem acesso as implementações e toda a comunicação é feita a partir de interfaces e adaptadores, por isso esse modelo também é chamado de ports and adapters.
\nEntão na raiz do projeto será criado a pasta domain e criaremos duas pastas a livro e a autor e começaremos pelo domínio do Livro no arquivo livro.ts:
export class Livro {\n\n name: string\n\n autor: Autor\n\n}E em seguida o domínio do Autor no arquivo autor.ts:
export class Autor {\n\n id: string\n\n name: string\n\n livros: Livro[]\n\n}E já iremos adicionar a nossa porta que será a interface de comunicação e nela iremos definir duas operações, a operação de salvar save e outra para buscar todo os livros findAll no arquivos livro.repository.ts:
export interface LivroRepository{\n\n save(livro: Livro): Promise<Livro>\n\n findAll(): Promise<Livro[]>\n}E por fim iremos definir o módulo de domínio no arquivo domain.module.ts:
import { Module } from '@nestjs/common';\n\n@Module({})\nexport default class DomainModule {}Quando definimos o módulo de domínio, que é o módulo mais ao centro da Arquitetura Hexagonal também criamos os casos de uso para aquele domínio, aqui vive a regra de negócio da aplicação.
\nVamos criar a pasta usecase e vamos criar dois arquivos, um para a regra de inserir um livro create-livro-service.ts:
import { Livro } from \"src/domain/livro/livro\";\nimport { LivroRepository } from \"src/domain/ports/livro.repository\";\n\nexport class CreateLivroService{\n constructor(private readonly repository: LivroRepository){}\n\n async create(livroDTO: Livro): Promise<Livro>{\n return this.repository.save(livroDTO)\n }\n}E outra para buscar todos os livros find-all-livro-service.ts:
import { Livro } from \"src/domain/livro/livro\";\nimport { LivroRepository } from \"src/domain/ports/livro.repository\";\n\nexport class FindAllLivroService{\n constructor(private readonly repository: LivroRepository){}\n\n async findAll(): Promise<Livro[]>{\n return this.repository.findAll()\n }\n}Um ponto importante que deve ser notado é que nas duas classes foram adicionadas ao construtor a interface LivroRepository e com isso é usado um conceito muito importante na Arquitetura Hexagonal que é a Injeção de Dependências e com isso desacoplamos o local onde roda a lógica de negócio na aplicação de frameworks ou tecnologias bastando ser criado um adaptador, seja ele usando um framework como no nosso exemplo com TypeORM ou com qualquer outro framework ou até mesmo codificando a conexão manualmente com o banco de dados, para a nossa porta LivroRepository.
\nOutro ponto importante é que como essa aplicação é mais simples os casos de uso são menores mas em aplicações mais complexas fica mais nítido a separação entre regras de negócio e implementações de tecnologias e frameworks. Onde a regra de negócio ficaria bem isolada do restante do código.
\nCom a definição do domínio e dos casos de uso, que compõe o core da aplicação está na hora de “plugar” os adaptadores que serão as implementações das portas definidas no domínio.
\nIniciaremos com o adaptador que irá se comunicar com a camada de persistência de dados, será usado o TypeORM para isso, que é um ORM inspirado no Hibernate, Doctrine e Entity Framework escrito em Javascript. Juntamente ao TypeORM será usado o banco de dados MySQL.
\nPara adicionar essas dependências na aplicação basta rodar o comando:
\nnpm install --save @nestjs/typeorm typeorm mysql2Agora criaremos a entidade que representará os dados persistidos no banco de dados. Criamos a pasta adapters/repository/typeorm/entity e dentro dela iremos criar o arquivo livro.entity.ts:
import { Column, Entity, ManyToOne, PrimaryGeneratedColumn } from \"typeorm\";\nimport { AutorEntity } from \"./autor.entity\";\n\n@Entity()\nexport class LivroEntity {\n\n @PrimaryGeneratedColumn()\n id: number;\n\n @Column({length:200})\n name: string;\n\n @ManyToOne(type => AutorEntity, autor => autor.livros, { cascade: ['insert'], eager: true })\n autor: AutorEntity\n}Aqui fizemos uso de Decorators que é uma feature do Typescript que são formas de adicionar metadados em uma classe, atributo ou método, são equivalentes as annotations do Java e do C#.
\nVamos entender uma a uma das annotations que foram adicionadas na classe LivroEntity:
\nid e também delega ao TypeORM a estratégia de geração do id.length da coluna.autor => autor.livros, a propagação através do cascade: ['insert'] onde fica definido que somente o insert irá propagar na entidade AutorEntity e por fim o atributo eager: true onde queremos explicitamente que quando houver uma busca na entidade LivroEntity também fará uma busca na entidade AutorEntity. Obs: a estratégia eager deve ser evitada nos casos onde a consulta possa retornar muitos resultados pois pode sobrecarregar o banco de dados e causar lentidões e problemas indesejados.
Agora será mostrado o mapeamento realizado na entidade AutorEntity no arquivo autor.entity.ts:
import { Column, Entity, OneToMany, PrimaryGeneratedColumn } from \"typeorm\";\nimport { LivroEntity } from \"./livro.entity\";\n\n@Entity()\nexport class AutorEntity {\n\n @PrimaryGeneratedColumn()\n id: number;\n\n @Column({ length: 100})\n name: string;\n\n @OneToMany(type => LivroEntity, livro => livro.autor, { cascade: ['remove'] })\n livros: LivroEntity[]\n\n}A única coisa diferente aqui é o Decorator @OneToMany() onde é definido o relacionamento One-to-Many entre AutorEntity e LivroEntity, a configuração de programação cascade: ['remove'] para que quando um Autor for removido do banco de dados os Livros também sejam removidos.
O mesmo pode ser representado pelo diagrama de modelo entidade relacionamento:
\nNo trecho acima tem muitas coisas interessantes acontecendo e vamos entender cada uma delas. Primeiramente importamos o módulo TypeOrmConfigModule pois aqui é onde incluiremos a injeção do adaptador do TypeORM: Logo em seguida é definido duas variáveis com os nomes FIND_ALL_LIVRO_SERVICE e CREATE_LIVRO_SERVICE elas serão usadas para fazer o que seria relativo a annotation @Qualifier que é usada no Java em que podemos usar para qualificarmos uma instância para ser injetada via um nome: Na sequência é feito uso do DynamicModule do NestJS onde podemos criar providers dinâmicamente passando o que deve ser injetado, nesse caso o LivroRepositoryTypeORM, um provider que será o nome pelo o qual iremos injetar a instância onde formos usar, podendo ser CREATE_LIVRO_SERVICE ou FIND_ALL_LIVRO_SERVICE no nosso exemplo e um método chamado useFactory que é um método que irá “fabricar” a instância desejada passando a dependência correta: E por fim é exportado as duas strings que são usadas para nomear os providers que serão injetados: Com essa configuração feita iremos criar o Controller: Os Decorators usados são de dois tipos e primeiramente vamos ver os que são usados para expor a API REST: Fora isso também temos o Decorator @Inject() e nele passamos o nome do qualificador que deve ser carregado para que a injeção de dependência seja feita de forma correta. Agora temos as duas pontas configuras e para que esse Controller esteja disponível para ser usado pela aplicação é necessário expô-lo como um módulo que será usado pelo NestJS: No código acima importamos da classe ConfigServiceModule o método register() para que os providers estejam disponíveis e informamos que esse módulo expõe um Controller que nesse caso é o LivroController. Para encerrar iremos criar a camada de application, é o módulo responsável pela entrada da aplicação. Criaremos o arquivo no path No código acima basicamente foi criado o módulo AppModule e importamos o ControllerModule sem necessidade de expor nada além para o funcionamento. A última configuração é necessária no arquivo Alteramos o padrão da função bootstrap e adicionamos a dependência do Fastify e é só isso, nenhuma configuração a mais para adicionar o Fastify como motor web da aplicação 😊 Antes de rodar a aplicação é necessário ter o MySQL rodando, mas para facilitar esse processo de infraestrutura iremos criar o MySQL pelo docker-compose. Na raiz do projeto basta criar o arquivo Adicionamos a imagem do MySQL, definimos as credenciais, portas, database e o volume que deve ser montado no start do container: E depois rodamos o comando na raiz do projeto: E agora para iniciar a aplicação podemos usar o comando a seguir: E para testar o endpoint podemos fazer um POST para inserir um livro com um autor associado: E teremos o resultado: E fazendo o GET: Teremos o resultado: Aqui aprendemos como usar o NestJS e como ele e o Typescript auxiliam o desenvolvedor a criar aplicações usando a tipagem estática do Typescript e o sistema de módulos e injeção de dependências do NestJS. Também vimos como usar o TypeORM para abstrair a comunicação com banco de dados e como conseguimos tirar vantagem de um padrão arquitetural como a Arquitetura Hexagonal para deixar a aplicação focada nas regras de negócio ao invés de ficar acoplada a tecnologias e frameworks. Por fim vimos como usar o Fastify na aplicação, o que é extremamente simples e transparante quando estamos usando NestJS. O código fonte desse projeto está disponível no Github@Module({\n imports: [TypeOrmConfigModule]\n})static FIND_ALL_LIVRO_SERVICE: string = 'FindAllLivroService';\nstatic CREATE_LIVRO_SERVICE: string = 'CreateLivroService'; static register(): DynamicModule {\n return {\n module: ConfigServiceModule,\n providers: [\n {\n inject: [LivroRepositoryTypeORM],\n provide: ConfigServiceModule.CREATE_LIVRO_SERVICE,\n useFactory: (livroRepository: LivroRepositoryTypeORM) => new CreateLivroService(livroRepository)\n },\n {\n inject: [LivroRepositoryTypeORM],\n provide: ConfigServiceModule.FIND_ALL_LIVRO_SERVICE,\n useFactory: (livroRepository: LivroRepositoryTypeORM) => new FindAllLivroService(livroRepository)\n }\n ],\n exports: [ConfigServiceModule.FIND_ALL_LIVRO_SERVICE, ConfigServiceModule.CREATE_LIVRO_SERVICE]\n }\n }exports: [ConfigServiceModule.FIND_ALL_LIVRO_SERVICE, ConfigServiceModule.CREATE_LIVRO_SERVICE]import { Body, Controller, Get, Inject, Post } from \"@nestjs/common\";\nimport { Livro } from \"src/domain/livro/livro\";\nimport { CreateLivroService } from \"src/usecase/create-livro-service\";\nimport { FindAllLivroService } from \"src/usecase/find-all-livro-service\";\nimport { ConfigServiceModule } from \"../config/config-service.module\";\n\n@Controller('livro')\nexport class LivroController {\n\n constructor(@Inject(ConfigServiceModule.CREATE_LIVRO_SERVICE) private readonly createLivroService: CreateLivroService,\n @Inject(ConfigServiceModule.FIND_ALL_LIVRO_SERVICE) private readonly findAllLivroService: FindAllLivroService){}\n\n @Get()\n public findAll(): Promise<Livro[]>{\n return this.findAllLivroService.findAll()\n }\n\n @Post()\n public createLivro(@Body() livro: Livro): Promise<Livro>{\n return this.createLivroService.create(livro)\n }\n\n}\n
\n@Module({\n imports: [ConfigServiceModule.register()],\n controllers: [LivroController]\n})\nexport class ControllerModule{}Application
\nsrc/application/app.module.ts:import { Module } from '@nestjs/common';\nimport { ControllerModule } from 'src/adapters/controller/rest/controller.module';\n\n@Module({\n imports: [ControllerModule]\n})\nexport class AppModule {}main.ts na raiz do projeto, esse é o arquivo que será executado pelo NestJS para iniciar a aplicação e é nele que iremos fazer a configuração do Fastify e a inserção do módulo AppModule:import { NestFactory } from '@nestjs/core';\nimport { FastifyAdapter, NestFastifyApplication } from '@nestjs/platform-fastify';\nimport { AppModule } from './application/app.module';\n\nasync function bootstrap() {\n const app = await NestFactory.create<NestFastifyApplication>(\n AppModule,\n new FastifyAdapter()\n );\n\n await app.listen(3000);\n}\nbootstrap().then((r) => r);Rodando a aplicação
\ndocker-compose.yml:version: '3'\nservices: \n\n mysql:\n image: mysql:8.0.17\n cap_add: \n - SYS_NICE\n environment: \n MYSQL_ROOT_PASSWORD: root\n MYSQL_USER: user\n MYSQL_PASSWORD: user\n MYSQL_DATABASE: bookstore\n ports: \n - \"3306:3306\"\n volumes: \n - ./data/cadastro-api.sql:/docker-entrypoint-initdb.d/cadastro-api.sqlCREATE DATABASE IF NOT EXISTS bookstore;\n\nGRANT ALL PRIVILEGES ON *.* TO 'user'@'%' WITH GRANT OPTION;\nFLUSH PRIVILEGES;\n\nALTER USER 'user' IDENTIFIED WITH mysql_native_password BY 'user';\nFLUSH PRIVILEGES;docker compose upnpm run start:devcurl --location --request POST 'localhost:3000/livro' \\\n--header 'Content-Type: application/json' \\\n--data-raw '{\n \"name\": \"Vidas secas\",\n \"autor\": {\n \"name\": \"Graciliano Ramos\"\n }\n}' | json_pp{\n \"name\": \"Vidas secas\",\n \"autor\": {\n \"name\": \"Graciliano Ramos\"\n }\n}curl --location --request GET 'localhost:3000/livro' \\\n--header 'Content-Type: application/json' \\\n--data-raw '{\n \"name\": \"Vidas secas\",\n \"autor\": {\n \"name\": \"Graciliano Ramos\"\n }\n}' | json_pp[\n {\n \"name\": \"Vidas secas\",\n \"autor\": {\n \"name\": \"Graciliano Ramos\"\n }\n }\n]Conclusão
\nCódigo fonte
\n