Como Integrar NestJS com MySQL: Guia Completo Passo a Passo

Por que usar NestJS com MySQL?

O NestJS é um framework poderoso e moderno para desenvolvimento back-end com Node.js, baseado em TypeScript e arquitetura modular. Já o MySQL é um dos bancos de dados relacionais mais populares do mundo, amplamente utilizado por sua performance, estabilidade e facilidade de uso.

Ao combinar NestJS com MySQL, você tem uma solução robusta e escalável para construir APIs RESTful, sistemas corporativos e aplicações back-end complexas. Essa integração é feita com auxílio do TypeORM, um ORM (Object Relational Mapping) que facilita a interação entre código e banco de dados.

1. Requisitos Iniciais

Antes de começar, certifique-se de ter instalado:

• Node.js (versão 14 ou superior)
• npm ou yarn
• MySQL Server (local ou remoto)

Além disso, instale as dependências necessárias para integrar NestJS com MySQL:

npm install @nestjs/typeorm typeorm mysql2

Explicando cada pacote:

• @nestjs/typeorm: permite integrar TypeORM ao NestJS
• typeorm: ORM para trabalhar com bancos de dados relacionais
• mysql2: driver do MySQL usado pelo TypeORM para se conectar ao banco

2. Configurar a Conexão com o Banco de Dados

A configuração da conexão com o MySQL é realizada no arquivo principal do módulo, geralmente localizado em src/main.ts ou src/app.module.ts.

Abra o arquivo app.module.ts e configure o módulo TypeORM:

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

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'root',
      password: 'sua-senha',
      database: 'nome-do-banco',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

Detalhes Importantes:

• type: define o tipo de banco (neste caso, ‘mysql’)
• entities: indica onde estão localizadas as entidades do projeto
• synchronize: atualiza automaticamente o esquema do banco (use apenas em ambiente de desenvolvimento)

⚠️ Em produção, desative a opção synchronize: true para evitar alterações indesejadas no banco de dados.

3. Criar uma Entidade do Banco de Dados

As entidades representam tabelas dentro do banco de dados. Vamos criar uma entidade chamada Article como exemplo:

// src/article/article.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Article {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  title: string;

  @Column()
  content: string;
}

Registre essa entidade no módulo correspondente:

// src/article/article.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ArticleController } from './article.controller';
import { ArticleService } from './article.service';
import { Article } from './article.entity';

@Module({
  imports: [TypeOrmModule.forFeature([Article])],
  controllers: [ArticleController],
  providers: [ArticleService],
})
export class ArticleModule {}

4. Implementar Serviço e Controlador para CRUD

Com a entidade criada, vamos implementar métodos de acesso ao banco no serviço e endpoints no controlador.

Serviço (Service)

// src/article/article.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Article } from './article.entity';

@Injectable()
export class ArticleService {
  constructor(
    @InjectRepository(Article)
    private articleRepository: Repository<Article>,
  ) {}

  findAll(): Promise<Article[]> {
    return this.articleRepository.find();
  }

  findOne(id: number): Promise<Article> {
    return this.articleRepository.findOneBy({ id });
  }

  create(article: Article): Promise<Article> {
    return this.articleRepository.save(article);
  }

  async remove(id: number): Promise<void> {
    await this.articleRepository.delete(id);
  }
}

Controlador (Controller)

// src/article/article.controller.ts
import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { ArticleService } from './article.service';
import { Article } from './article.entity';

@Controller('articles')
export class ArticleController {
  constructor(private readonly articleService: ArticleService) {}

  @Get()
  findAll() {
    return this.articleService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: number) {
    return this.articleService.findOne(id);
  }

  @Post()
  create(@Body() article: Article) {
    return this.articleService.create(article);
  }

  @Delete(':id')
  remove(@Param('id') id: number) {
    return this.articleService.remove(id);
  }
}

5. Executar e Testar a Aplicação

Inicie o servidor com o comando:

npm run start

Você pode testar os endpoints usando ferramentas como o Postman ou o curl:

Método	Rota	Função
GET	/articles	Listar todos os artigos
GET	/articles/:id	Buscar artigo por ID
POST	/articles	Criar novo artigo
DELETE	/articles/:id	Excluir artigo por ID

Se tudo estiver configurado corretamente, o NestJS estará conectado ao MySQL e realizando operações de leitura e escrita com sucesso.

6. Melhorias Recomendadas

Para deixar sua aplicação ainda mais profissional e segura, você pode adicionar:

• Validação de campos com pipes do NestJS
• Autenticação JWT para proteger suas rotas
• Documentação da API usando Swagger
• Tratamento centralizado de exceções
• Logs detalhados com Winston ou outro logger

Essas práticas ajudam a melhorar a qualidade do código, a segurança e a manutenibilidade do sistema.

Conclusão

Integrar NestJS com MySQL usando TypeORM é uma abordagem eficiente e recomendada para projetos back-end modernos. Com esse setup, você consegue construir APIs escaláveis, bem estruturadas e fáceis de manter.

Se você está começando com NestJS ou precisa montar um sistema completo com banco de dados relacional, seguir este guia passo a passo é um excelente ponto de partida.

Dica final: Para aprender mais sobre NestJS e TypeORM, consulte a documentação oficial do NestJS e do TypeORM.