Como construir uma API REST CRUD Nest.js usando TypeORM e PostgreSQL

Como outras estruturas do Node.js, o Nest.js fornece um kit de ferramentas abrangente para criar serviços de back-end robustos e escalonáveis. No entanto, é importante entender como implementar a criação, leitura, atualização e exclusão (CRUD) no Nest.js de forma eficiente — essas são as operações mais fundamentais no desenvolvimento de APIs.

Saiba como criar uma API REST CRUD Nest.js usando TypeORM e um banco de dados PostgreSQL.

Introdução ao Nest.js

Para começar, instale a ferramenta de linha de comando Nest.js:

npm i -g @nestjs/cli

Em seguida, crie um novo projeto executando:

aninhar novo aplicativo crud

A ferramenta CLI solicitará que você escolha um gerenciador de pacotes, escolha a opção que achar mais preferível. nós vamos usar npm, o gerenciador de pacotes Node.

A CLI criará um projeto Nest.js básico com todos os arquivos de configuração necessários e as dependências iniciais necessárias para executar o aplicativo.

Por fim, navegue até o diretório do projeto e inicie o servidor de desenvolvimento.

cd crud-app
npm executar início

Você pode encontrar o código deste projeto em seu GitHub repositório.

Criar um banco de dados PostgreSQL

Este tutorial usa uma instância do PostgreSQL na nuvem, mas você pode configurar um banco de dados PostgreSQL local. Você pode instalar o PostgreSQL no Windows, no macOS, ou no Linux.

Para configurar uma instância do PostgreSQL na nuvem:

1. Dirija-se a ElefanteSQL, inscreva-se e faça login na página de visão geral da sua conta.
2. Clique no Criar nova instância botão na seção superior esquerda da página para criar uma nova instância para seu aplicativo.
3. Preencha o nome da sua instância, escolha o plano gratuito e, por fim, selecione a região para concluir o processo de configuração.
4. Depois de criar a instância do banco de dados, vá para o configurações página e copie o fornecido URL do banco de dados.

Configurar a conexão do banco de dados

No diretório raiz do seu projeto, crie um .env arquivo e cole a URL de conexão com o banco de dados da seguinte forma:

DATABASE_URL=""

Agora instale estes pacotes:

npm install pg typeorm @nestjs/typeorm @nestjs/config

Em seguida, vá em frente e crie um módulo de banco de dados usando a ferramenta CLI.

banco de dados do módulo nest g

Abra o database/database.module.ts arquivo e adicione o seguinte código de configuração do banco de dados:

importar { Módulo } de'@nestjs/common';
importar { ConfigModule, ConfigServiço } de'@nestjs/config';
importar { TypeOrmModule } de'@nestjs/typeorm';
importar { Do utilizador } de'../users/models/user.entity'; 
@Módulo({
 importações: [
 TypeOrmModule.forRootAsync({
 importa: [ConfigModule], 
 injetar: [ConfigServiço],
 useFábrica: assíncrono (configService: ConfigService) => ({
tipo: 'postgres',
 url: configService.get('DATABASE_URL'), 
 entidades: [Usuário],
 sincronizar: verdadeiro
 }),
 }),
 ],
})
exportaraula Módulo de banco de dados {}

Este módulo de banco de dados lida com a conexão configurando o módulo TypeORM com o parâmetro de conexão necessário, a URL do banco de dados.

Além disso, define a entidade Usuário como parte da configuração que especifica a estrutura e as propriedades dos dados armazenados na tabela do banco de dados PostgreSQL.

Nesse estágio, seu código provavelmente gerará um erro porque você ainda não criou a entidade de usuários. Você fará isso nas etapas a seguir.

Atualize o arquivo app.module.ts

Por fim, atualize o módulo principal do aplicativo para incluir a configuração do módulo de banco de dados.

importar { Módulo } de'@nestjs/common';
importar { Módulo de Configuração } de'@nestjs/config';
importar { AplicativoControlador } de'./app.controller';
importar { Serviço de Aplicativo } de'./app.service';
importar { Módulo de banco de dados } de'./database/database.module';
@Módulo({
 importações: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 Módulo de banco de dados,
 ],
 controladores: [AppController],
 provedores: [AppService],
})
exportaraula AppModule {}

Definir um módulo de usuários

O módulo de usuários serve como um componente centralizado, responsável por encapsular e gerenciar a lógica necessária para implementar a funcionalidade CRUD da API.

Execute este comando de terminal para criar o módulo de usuários da API.

usuários do módulo nest g

A ferramenta CLI atualiza automaticamente o app.module.ts arquivo para refletir as alterações feitas, além de criar o módulo de usuário. Isso garante que o módulo recém-criado, users, seja devidamente integrado à configuração do módulo do aplicativo.

Criar uma entidade de usuário

TypeORM é uma biblioteca Object-Relational Mapping (ORM) que simplifica as interações de banco de dados em aplicativos que usam TypeScript mapeando objetos JavaScript para tabelas de banco de dados.

Ao criar uma entidade de usuário usando TypeORM, você define a estrutura e as propriedades dos dados do usuário no banco de dados PostgreSQL.

No diretório de usuários, crie um novo modelos/usuário.entidade.ts e adicione o seguinte código.

importar { Entity, PrimaryGeneratedColumn, Column, } de"typeorm";
@Entidade()
exportaraula Do utilizador {
@PrimaryGeneratedColumn()
 eu ia: número;
@Coluna()
 nome: corda;
@Coluna()
 e-mail: corda;
}

O Do utilizador A entidade define a estrutura dos dados do usuário armazenados no banco de dados. Nesse caso, esse é o eu ia como a coluna de chave primária, e o nome e e-mail colunas e suas propriedades correspondentes.

Crie o serviço de API CRUD

Agora, crie o serviço de API que irá gerenciar a lógica das operações CRUD executando o comando abaixo:

usuários do serviço nest g

Abra o usuário-auth.service.ts arquivo e adicione este código:

importar { Injetável } de'@nestjs/common';
importar {InjectRepository} de'@nestjs/typeorm';
importar { Repositório } de'typeorm';
importar {Do utilizador} de'./models/user.entity';
@Injetável()
exportaraula UsuáriosServiço {
construtor(
@InjectRepository(Do utilizador)
privado userRepository: Repositório,
 ) {}
assíncrono encontrar tudo(): Promessa {
retornaresse.userRepository.find();
 }
assíncrono encontrarUm (id: número): Promessa {
retornaresse.userRepository.findOne({ onde: { id } });
 }
assíncrono criar (usuário: Parcial): Promessa {
const novousuário = esse.userRepository.create (usuário);
retornaresse.userRepository.save (novo usuário);
 }
assíncrono atualizar (id: número, usuário: Parcial): Promessa {
aguardamesse.userRepository.update (id, usuário);
retornaresse.userRepository.findOne({ onde: { id } });
 }
assíncronoexcluir(eu ia: número): Promessa<vazio> {
aguardamesse.userRepository.delete (id);
 }
}

Essa classe UsersService define vários métodos de API dedicados ao tratamento de operações CRUD. Esses métodos incluem buscar os dados de todos os usuários, encontrar um usuário específico usando seu número de ID, criar um novo usuário, atualizando um usuário existente e um método para excluir os dados de um usuário específico no banco de dados.

Definir um controlador para a API

Crie um controlador que gerenciará os endpoints da API para as operações relacionadas ao usuário.

usuários do controlador Nest G

Em seguida, adicione o código abaixo ao usuários.controlador.ts arquivo.

importar { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } de'@nestjs/common';
importar { Serviço de usuários } de'./users.service';
importar { Do utilizador } de'./models/user.entity';
@Controlador('API/usuários')
exportaraula UsuáriosControlador {
construtor(privado readonly usersService: UsersService) {}
@Pegar()
assíncrono encontrar tudo(): Promessa {
retornaresse.usersService.findAll();
 }
@Publicar()
@HttpCode(201) 
assíncrono criar(@Corpo() usuario: usuario): Promessa {
const criadoUsuário = aguardamesse.usersService.create (usuário);
retornar criadoUsuário;
 }
@Colocar(':eu ia')
assíncrono atualizar (@Param('eu ia') eu ia: número, @Corpo() usuario: usuario): Promessa<qualquer> {
aguardamesse.usersService.update (id, usuário);
retornar { mensagem: 'Usuário atualizado com sucesso' };
 }
@Excluir(':eu ia')
assíncronoexcluir(@Param('eu ia') eu ia: número): Promessa<qualquer> {
const usuário = aguardamesse.usersService.findOne (id);
se (!do utilizador) {
lançarnovo NotFoundException('Usuário não existe!');
 }
aguardamesse.usersService.delete (id);
retornar { mensagem: 'Usuário deletado com sucesso' };
 }
}

O controlador gerencia endpoints de API para operações do usuário. Ele lida com solicitações GET para recuperar todos os usuários, solicitações POST para criar novos usuários, solicitações PUT para atualizar usuários existentes e solicitações DELETE para excluir usuários.

Ao utilizar o UsuáriosServiço e interagindo com o Do utilizador entidade, este controlador fornece uma API completa para gerenciar operações relacionadas ao usuário nos dados armazenados no banco de dados.

Atualize o arquivo users.module.ts

Por último, atualize o users.module.ts arquivo conforme mostrado abaixo para garantir que você incorpore o Entidade de usuário e o módulo TypeORM, que estabelece a conexão com o banco de dados.

importar { Módulo } de'@nestjs/common';
importar { UsuáriosControlador } de'./users.controller';
importar { Serviço de usuários } de'./users.service';
importar { TypeOrmModule } de'@nestjs/typeorm';
importar { Do utilizador } de'./models/user.entity';
@Módulo({
 importações: [TypeOrmModule.forFeature([User])],
 controladores: [UsersController],
 provedores: [UsersService]
})
exportaraula Módulo de usuários {}

Por fim, vá em frente e ative o servidor de desenvolvimento para testar as operações CRUD usando o Postman.

npm executar início

O servidor iniciará na porta 3000 e você poderá enviar solicitações de API para ele em http://localhost: 3000/API/usuários.

Construindo aplicativos de back-end com Nest.js

Esteja você desenvolvendo uma API REST simples ou um aplicativo da Web complexo, o Nest.js oferece um conjunto abrangente de recursos e funcionalidades para construir um sistema de back-end confiável e robusto.

O Nest.js oferece uma abordagem mais estruturada para o desenvolvimento de projetos do que o Express.js. Isso garante que você possa criar, dimensionar e manter com confiança aplicativos complexos, graças ao seu padrão de design organizado e modular.