Como criar uma API com NestJS e MySQL

No universo do desenvolvimento backend, a criação de APIs robustas, escaláveis e bem estruturadas é um dos principais desafios enfrentados por desenvolvedores. Nesse cenário, o NestJS tem ganhado cada vez mais destaque por oferecer uma arquitetura sólida baseada em TypeScript, inspirada em conceitos do Angular, e que facilita a construção de aplicações modernas, organizadas e fáceis de manter.

O NestJS é especialmente utilizado no desenvolvimento de APIs porque segue padrões como Injeção de Dependência, Programação Orientada a Objetos (POO) e Modularização, tornando o código mais limpo e reutilizável. Além disso, ele já vem preparado para lidar com práticas importantes do mercado, como validações, tratamento de exceções e integração com diversos bancos de dados.

Quando falamos em persistência de dados, o MySQL continua sendo uma das opções mais utilizadas no mercado. Trata-se de um banco de dados relacional, confiável, maduro e com grande suporte da comunidade. Suas principais vantagens incluem:

• Estabilidade e desempenho em aplicações que exigem alto volume de dados.
  
• Ampla compatibilidade com frameworks e bibliotecas de backend.
  
• Suporte a consultas complexas utilizando SQL.
  
• Custo zero por ser open source, além de oferecer versões otimizadas em provedores de nuvem.
  

Neste artigo, você aprenderá como criar uma API com NestJS e MySQL, passando desde a configuração inicial do projeto, integração com o banco de dados, criação de entidades e rotas até boas práticas para manter o código organizado e pronto para escalar.

• Pré-requisitos
• Antes de começarmos a construir nossa API, é importante garantir que você já tenha preparado o ambiente de desenvolvimento. Os pontos a seguir são fundamentais para que o passo a passo funcione sem problemas:
• 1. Node.js instalado
• O NestJS é baseado em Node.js, portanto é necessário ter o Node instalado em sua máquina. Recomenda-se a versão LTS (Long Term Support), que garante maior estabilidade e suporte da comunidade.
  Você pode baixar o Node.js diretamente do site oficial: https://nodejs.org.
• 2. MySQL instalado e configurado
• Como vamos utilizar o MySQL como banco de dados relacional, é necessário tê-lo instalado e rodando localmente ou em um servidor. Caso esteja em ambiente de desenvolvimento, você pode instalar o MySQL em sua máquina ou usar soluções como XAMPP, Docker ou até serviços em nuvem.
  Certifique-se também de criar um banco de dados vazio que será utilizado pelo projeto.
• 3. Conhecimentos básicos de TypeScript e bancos de dados relacionais
• O NestJS utiliza TypeScript como linguagem principal, portanto é importante ter uma noção básica de tipagem, classes e interfaces. Além disso, compreender conceitos de bancos relacionais (tabelas, colunas, relacionamentos, chaves primárias/estrangeiras) ajudará bastante no entendimento da integração com o MySQL.
• 4. Editor de código (VSCode recomendado)
• Embora qualquer editor possa ser utilizado, o Visual Studio Code (VSCode) é altamente recomendado, pois oferece extensões específicas para TypeScript, NestJS e bancos de dados, tornando o desenvolvimento mais produtivo.
  Download: https://code.visualstudio.com.
• Com esses pré-requisitos atendidos, já estaremos prontos para iniciar a criação do projeto NestJS e integrar nossa API ao MySQL.

Criando o projeto NestJS

Agora que temos o ambiente preparado, o próximo passo é criar o projeto base utilizando o NestJS CLI, uma ferramenta de linha de comando que facilita a criação e o gerenciamento de projetos no framework.

1. Instalação do NestJS CLI

O NestJS possui um CLI próprio que ajuda a gerar módulos, controllers, services e outros elementos de forma rápida e organizada. Para instalar, utilize o comando:

npm install -g @nestjs/cli

Após a instalação, você pode verificar se o CLI está funcionando corretamente rodando:

nest --version

Se aparecer a versão instalada, significa que tudo ocorreu bem.

2. Comando para criar um novo projeto

Com o CLI instalado, podemos criar um novo projeto executando:

nest new api-nest-mysql

Durante o processo, o NestJS CLI perguntará qual gerenciador de pacotes você deseja utilizar (npm ou yarn). Escolha o que preferir — neste exemplo, vamos usar o npm.

Esse comando irá gerar automaticamente uma estrutura inicial de projeto já configurada para começar o desenvolvimento.

3. Estrutura inicial de pastas e arquivos do NestJS

Após a criação, você verá uma estrutura parecida com esta:

api-nest-mysql/
├── src/
│   ├── app.controller.ts
│   ├── app.module.ts
│   ├── app.service.ts
│   └── main.ts
├── test/
├── package.json
├── tsconfig.json
└── nest-cli.json

• main.ts → Arquivo de entrada da aplicação.
  
• app.module.ts → Módulo raiz onde os outros módulos serão importados.
  
• app.controller.ts → Exemplo de controller com uma rota inicial.
  
• app.service.ts → Serviço responsável pela lógica do exemplo padrão.
  

Essa organização modular é um dos pontos fortes do NestJS, pois permite dividir responsabilidades e manter o código limpo e escalável.

Na próxima etapa, vamos configurar a integração com o MySQL, instalando e ajustando o ORM para conectar nosso projeto ao banco de dados.

Configurando o MySQL no NestJS

Com o projeto NestJS criado, o próximo passo é configurar a conexão com o MySQL, que será responsável por armazenar e gerenciar os dados da nossa aplicação. Para isso, vamos utilizar o TypeORM, um dos ORMs mais populares no ecossistema NestJS.

1. Instalação do TypeORM (ou Prisma como alternativa)

O TypeORM é a escolha mais comum para projetos com NestJS porque oferece suporte nativo e se integra de forma simples ao framework. Para instalar, execute:

npm install --save @nestjs/typeorm typeorm mysql2

@nestjs/typeorm → Integração oficial do NestJS com o TypeORM.

typeorm → Biblioteca ORM que fará o mapeamento objeto-relacional.

mysql2 → Driver que permite a conexão com bancos MySQL.

Alternativa: Caso prefira, também é possível usar o Prisma, que vem ganhando espaço por ser mais simples e oferecer uma abordagem baseada em schema. Mas, neste artigo, seguiremos com o TypeORM.

2. Configuração do módulo de conexão com o banco de dados

No NestJS, a conexão com o banco é configurada dentro do AppModule. Abra o arquivo src/app.module.ts e adicione o seguinte:

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: 'api_nest_mysql',
      autoLoadEntities: true,
      synchronize: true, // Atenção: use apenas em desenvolvimento!
    }),
  ],
})
export class AppModule {}

Explicando os parâmetros:

• host → Endereço onde o banco está rodando (localhost no ambiente local).
  
• username e password → Usuário e senha do banco.
  
• database → Nome do banco de dados que vamos usar.
  
• autoLoadEntities → Carrega automaticamente as entidades registradas.
  
• synchronize → Cria/atualiza as tabelas automaticamente a partir das entidades (útil em desenvolvimento, mas perigoso em produção).
  

3. Criando a base de dados no MySQL

Antes de rodar a aplicação, precisamos criar o banco de dados no MySQL. Acesse seu terminal ou client SQL e execute:

CREATE DATABASE api_nest_mysql;

Isso garantirá que o NestJS tenha um espaço no MySQL para criar as tabelas automaticamente (quando começarmos a definir as entidades).

Com a conexão configurada e o banco criado, já temos o alicerce pronto para começar a trabalhar com entidades e repositórios. Na próxima etapa, vamos criar nossa primeira entidade User e preparar o CRUD.

Criando uma entidade e um repositório

Agora que já temos o projeto conectado ao MySQL, podemos começar a modelar nossos dados. Para deixar o exemplo prático, vamos criar uma tabela chamada users, que representará os usuários do sistema.

1. Definição de um exemplo prático (tabela users)

Nossa tabela users terá os seguintes campos:

• id (chave primária, gerada automaticamente).
  
• name (nome do usuário).
  
• email (e-mail do usuário, único).
  
• createdAt (data de criação do registro).
  

Isso já é suficiente para ilustrar um CRUD básico.

2. Criando a entidade User com TypeORM

No NestJS, as entidades representam as tabelas do banco de dados. Vamos criar a entidade User dentro da pasta src/users/.Crie o arquivo src/users/user.entity.ts com o seguinte conteúdo:

import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';

@Entity('users')
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({ length: 100 })
  name: string;

  @Column({ unique: true })
  email: string;

  @CreateDateColumn({ type: 'timestamp' })
  createdAt: Date;
}

Explicando os decoradores:

• @Entity(‘users’) → Informa ao TypeORM que esta classe será mapeada para a tabela users.
  
• @PrimaryGeneratedColumn() → Cria uma chave primária com incremento automático.
  
• @Column() → Define uma coluna normal.
  
• @CreateDateColumn() → Gera automaticamente a data de criação do registro.
  

3. Configuração do repositório para acessar os dados

Para manipular os dados dessa tabela, o NestJS integra o conceito de repositories (repositórios), que permitem realizar operações no banco de forma simplificada.

No módulo UsersModule, vamos registrar a entidade para que o NestJS saiba que ela deve ser carregada pelo TypeORM.Crie o arquivo src/users/users.module.ts:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  exports: [TypeOrmModule],
})
export class UsersModule {}

O TypeOrmModule.forFeature([User]) registra a entidade no escopo do módulo, permitindo que possamos injetar o repositório correspondente em nossos services.

Agora já temos uma entidade User representando nossa tabela users e o repositório configurado. O próximo passo será criar o módulo, controller e service para expor os métodos CRUD através da API.

Criando o módulo, controller e service

Agora que já temos a entidade User e o repositório configurados, vamos estruturar o fluxo da aplicação criando um módulo, um service (onde ficará a lógica de negócio) e um controller (que expõe as rotas da API).

1. Criando o módulo UsersModule

O NestJS é baseado em uma arquitetura modular, e cada funcionalidade deve ser agrupada em módulos. Já criamos a base do UsersModule, mas agora vamos expandi-lo para incluir o controller e o service.Edite o arquivo src/users/users.module.ts:

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

2. Implementando o UsersService com métodos CRUD

O service é responsável pela lógica de negócio e pelas operações no banco de dados. Vamos criar o arquivo src/users/users.service.ts:

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';

@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

  async create(userData: Partial<User>): Promise<User> {
    const user = this.userRepository.create(userData);
    return await this.userRepository.save(user);
  }

  async findAll(): Promise<User[]> {
    return await this.userRepository.find();
  }

  async findOne(id: number): Promise<User> {
    return await this.userRepository.findOneBy({ id });
  }

  async update(id: number, updateData: Partial<User>): Promise<User> {
    await this.userRepository.update(id, updateData);
    return this.findOne(id);
  }

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

Explicando:

• create() → Cria e salva um novo usuário.
  
• findAll() → Retorna todos os usuários cadastrados.
  
• findOne() → Busca um usuário específico pelo ID.
  
• update() → Atualiza os dados de um usuário.
  
• remove() → Remove um usuário do banco.
  

3. Criando o UsersController com rotas HTTP

O controller expõe os métodos do service através de rotas HTTP. Crie o arquivo src/users/users.controller.ts:

import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './user.entity';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  async create(@Body() userData: Partial<User>): Promise<User> {
    return this.usersService.create(userData);
  }

  @Get()
  async findAll(): Promise<User[]> {
    return this.usersService.findAll();
  }

  @Get(':id')
  async findOne(@Param('id') id: number): Promise<User> {
    return this.usersService.findOne(id);
  }

  @Put(':id')
  async update(
    @Param('id') id: number,
    @Body() updateData: Partial<User>,
  ): Promise<User> {
    return this.usersService.update(id, updateData);
  }

  @Delete(':id')
  async remove(@Param('id') id: number): Promise<void> {
    return this.usersService.remove(id);
  }
}

Agora temos os seguintes endpoints disponíveis:

• POST /users → Criar usuário.
  
• GET /users → Listar todos os usuários.
  
• GET /users/:id → Buscar usuário por ID.
  
• PUT /users/:id → Atualizar usuário.
  
• DELETE /users/:id → Excluir usuário.
  

---

Com isso, finalizamos a estrutura básica de CRUD para a entidade User. Na próxima seção, vamos testar a API utilizando ferramentas como Postman ou Insomnia para garantir que tudo está funcionando corretamente.

Testando a API

Com o módulo, service e controller prontos, já temos nossa API funcionando. Agora é hora de testar os endpoints para verificar se o CRUD está respondendo corretamente. Para isso, podemos usar ferramentas como Insomnia ou Postman, que facilitam a criação de requisições HTTP.

1. Usando o Insomnia ou Postman

• Postman: disponível em https://www.postman.com.
  
• Insomnia: disponível em https://insomnia.rest.
  

Ambos permitem criar coleções de testes, enviar requisições e visualizar as respostas da API.

2. Exemplos de requisições

🔹 Criar um usuário (POST /users)

POST http://localhost:3000/users
Content-Type: application/json
{
  "name": "João da Silva",
  "email": "joao.silva@example.com"
}

Resposta esperada:

{
  "id": 1,
  "name": "João da Silva",
  "email": "joao.silva@example.com",
  "createdAt": "2025-08-30T18:15:23.000Z"
}

🔹 Listar todos os usuários (GET /users)

GET http://localhost:3000/users

Resposta esperada:

[
  {
    "id": 1,
    "name": "João da Silva",
    "email": "joao.silva@example.com",
    "createdAt": "2025-08-30T18:15:23.000Z"
  }
]

🔹 Buscar usuário por ID (GET /users/:id)

GET http://localhost:3000/users/1

Resposta esperada:

{
  "id": 1,
  "name": "João da Silva",
  "email": "joao.silva@example.com",
  "createdAt": "2025-08-30T18:15:23.000Z"
}

🔹 Atualizar usuário (PUT /users/:id)

PUT http://localhost:3000/users/1
Content-Type: application/json

{
  "name": "João da Silva Neto"
}

Resposta esperada:

{
  "id": 1,
  "name": "João da Silva Neto",
  "email": "joao.silva@example.com",
  "createdAt": "2025-08-30T18:15:23.000Z"
}

🔹 Remover usuário (DELETE /users/:id)

DELETE http://localhost:3000/users/1

Resposta esperada:

{}

Agora conseguimos criar, listar, buscar, atualizar e excluir usuários do banco MySQL diretamente pela API NestJS.

Na próxima seção, vamos explorar tratamento de erros e validações, para tornar nossa aplicação mais confiável e segura.

• Tratamento de erros e validações
• Uma API robusta não pode confiar apenas na estrutura básica de CRUD. É essencial garantir que os dados recebidos sejam válidos e que erros sejam tratados de forma clara e padronizada. O NestJS oferece suporte nativo a bibliotecas como class-validator e class-transformer, além de um sistema poderoso de filtros de exceções para lidar com erros.
• 1. Implementando validações com class-validator e class-transformer
• Essas duas bibliotecas são amplamente utilizadas em conjunto no NestJS para validar e transformar os dados recebidos nas requisições. Para instalá-las, rode:

npm install class-validator class-transformer

• Agora, vamos criar DTOs (Data Transfer Objects) para garantir que os dados enviados ao criar ou atualizar um usuário sigam as regras definidas.

Crie o arquivo src/users/dto/create-user.dto.ts:

import { IsEmail, IsNotEmpty, Length } from 'class-validator';


export class CreateUserDto {
  @IsNotEmpty({ message: 'O nome é obrigatório.' })
  @Length(3, 100, { message: 'O nome deve ter entre 3 e 100 caracteres.' })
  name: string;


  @IsEmail({}, { message: 'E-mail inválido.' })
  email: string;
}

E para atualizações, podemos ter um DTO mais flexível:

src/users/dto/update-user.dto.ts:

import { IsEmail, IsOptional, Length } from 'class-validator';


export class UpdateUserDto {
  @IsOptional()
  @Length(3, 100, { message: 'O nome deve ter entre 3 e 100 caracteres.' })
  name?: string;


  @IsOptional()
  @IsEmail({}, { message: 'E-mail inválido.' })
  email?: string;
}

Em seguida, ajustamos o controller para usar os DTOs:

import { Body, Controller, Post, Get, Param, Put, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './user.entity';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';


@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}


  @Post()
  async create(@Body() userData: CreateUserDto): Promise<User> {
    return this.usersService.create(userData);
  }


  @Put(':id')
  async update(
    @Param('id') id: number,
    @Body() updateData: UpdateUserDto,
  ): Promise<User> {
    return this.usersService.update(id, updateData);
  }
}

Para ativar a validação globalmente, edite main.ts:

import { ValidationPipe } from '@nestjs/common';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';


async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalPipes(new ValidationPipe({ transform: true }));
  await app.listen(3000);
}
bootstrap();

• Agora, sempre que uma requisição for feita, o NestJS verificará se os dados seguem as regras definidas nos DTOs.
• 2. Tratamento de exceções no NestJS
• Além das validações, precisamos tratar erros que podem acontecer, como usuário não encontrado ou falha no banco de dados.
• O NestJS possui a classe HttpException, que nos permite lançar erros personalizados. Por exemplo, no UsersService:

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';


@Injectable()
export class UsersService {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}


  async findOne(id: number): Promise<User> {
    const user = await this.userRepository.findOneBy({ id });
    if (!user) {
      throw new NotFoundException(`Usuário com ID ${id} não encontrado`);
    }
    return user;
  }
}

• Aqui usamos NotFoundException, que já retorna um erro 404 com a mensagem configurada.
• Exception Filters
• Para casos mais avançados, podemos criar Exception Filters, que são classes responsáveis por capturar e personalizar a resposta de erros.
• Exemplo de um filtro genérico:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';
import { Response } from 'express';


@Catch(HttpException)
export class HttpErrorFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const status = exception.getStatus();
    const errorResponse = {
      statusCode: status,
      message: exception.message,
      timestamp: new Date().toISOString(),
    };


    response.status(status).json(errorResponse);
  }
}

Para aplicar globalmente, adicione em main.ts:

import { HttpErrorFilter } from './common/filters/http-error.filter';


app.useGlobalFilters(new HttpErrorFilter());

• Com isso, garantimos que nossa API NestJS com MySQL não só valida os dados corretamente, mas também trata os erros de forma clara e consistente para o cliente.
• Na próxima seção, veremos algumas melhorias e boas práticas para deixar a aplicação ainda mais organizada e pronta para crescer.

Melhorias e boas práticas

Ao longo do desenvolvimento de uma API com NestJS e MySQL, algumas práticas podem fazer toda a diferença em termos de escalabilidade, organização e manutenção do projeto. Vamos ver algumas delas:

Organização de módulos

No NestJS, tudo gira em torno de módulos, que agrupam controllers, services e entidades relacionados. Em projetos maiores, é comum separar os módulos por contexto (ex.: UsersModule, ProductsModule, OrdersModule). Essa separação facilita a manutenção e o trabalho em equipe, além de deixar o código mais limpo e modular.

Dica: evite concentrar toda a lógica em um único módulo AppModule. Divida as responsabilidades.

Uso de DTOs (Data Transfer Objects)

Os DTOs são classes que definem como os dados devem ser recebidos ou enviados pela aplicação. Eles ajudam a validar e tipar os dados corretamente.

Exemplo de DTO para criação de um usuário: src/users/dto/create-user.dto.ts

import { IsEmail, IsNotEmpty, MinLength } from 'class-validator';


export class CreateUserDto {
  @IsNotEmpty()
  name: string;


  @IsEmail()
  email: string;


  @MinLength(6)
  password: string;
}

Esse padrão garante que somente os dados esperados sejam processados pelo serviço, evitando inconsistências.

Configuração de variáveis de ambiente com @nestjs/config

Nunca é uma boa prática deixar credenciais ou configurações sensíveis fixas no código. Para resolver isso, use o pacote @nestjs/config, que permite carregar variáveis de ambiente a partir de arquivos .env. Exemplo de configuração no app.module.ts:

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

@Module({
  imports: [
    ConfigModule.forRoot({
      isGlobal: true, // Disponível em toda a aplicação
    }),
  ],
})
export class AppModule {}

E no arquivo .env:

DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASS=secret
DB_NAME=nestjs_db

Assim, a aplicação se torna mais segura e fácil de configurar em diferentes ambientes (desenvolvimento, homologação, produção).

Possibilidade de autenticação (JWT)

Uma API raramente fica completa sem autenticação. Uma abordagem comum no NestJS é usar JWT (JSON Web Token). O fluxo básico é:

1. O usuário faz login e recebe um token JWT.
   
2. Esse token é enviado no header Authorization em cada requisição.
   
3. O servidor valida o token antes de permitir o acesso às rotas protegidas.
   

O NestJS já possui o módulo @nestjs/jwt, que simplifica a implementação desse processo.

Resumo: Ao aplicar boas práticas como a modularização, uso de DTOs, variáveis de ambiente e autenticação, sua API com NestJS e MySQL ficará muito mais robusta, segura e preparada para crescer.

Conclusão

Neste artigo, mostramos como criar uma API com NestJS e MySQL, passo a passo, desde a configuração inicial do projeto até a criação de um CRUD completo para a entidade User. Vamos recapitular rapidamente o que foi feito:

1. Preparação do ambiente: instalamos Node.js, MySQL e configuramos o editor de código.
   
2. Criação do projeto NestJS: utilizamos o NestJS CLI e conhecemos a estrutura de pastas e arquivos.
   
3. Integração com MySQL: instalamos e configuramos o TypeORM para conectar o projeto ao banco de dados.
   
4. Criação de entidade e repositório: modelamos a tabela users e configuramos o repositório para acesso aos dados.
   
5. Módulo, service e controller: implementamos o UsersModule, UsersService com métodos CRUD e o UsersController para expor as rotas HTTP.
   
6. Testes da API: utilizamos Postman/Insomnia para criar, listar, atualizar, buscar e remover usuários.
   
7. Tratamento de erros e validações: aplicamos class-validator e class-transformer para validar os dados e tratamos exceções com HttpException e filtros de erros.
   
8. Boas práticas: aplicamos modularização, uso de DTOs, variáveis de ambiente com @nestjs/config e discutimos a possibilidade de implementar autenticação via JWT.
   

Benefícios de usar NestJS + MySQL

• Arquitetura modular e organizada: facilita manutenção e escalabilidade.
  
• TypeScript nativo: código mais seguro e fácil de entender.
  
• Integração com diversos bancos: MySQL é confiável, maduro e amplamente utilizado.
  
• Suporte a boas práticas: validação, tratamento de erros, autenticação e modularização nativa.
  

Próximos passos

Agora que sua API básica está funcionando, você pode expandi-la com recursos avançados, como:

• Autenticação e autorização usando JWT ou OAuth2.
  
• Versionamento da API para gerenciar diferentes releases de endpoints.
  
• Deploy em nuvem (Heroku, AWS, Google Cloud) para disponibilizar sua API para clientes ou aplicativos front-end.
  
• Monitoramento e logs para acompanhar o desempenho e possíveis erros em produção.
  

Com esses conhecimentos, você está pronto para construir APIs completas, escaláveis e seguras utilizando NestJS e MySQL, abrindo caminho para projetos mais complexos e profissionais.

Agora que você acompanhou o passo a passo completo de como criar uma API com NestJS e MySQL, é hora de colocar a mão na massa! Teste o projeto em sua máquina, experimente criar novos endpoints, modificar entidades e explorar os recursos do NestJS.

Para aprofundar seus conhecimentos e consultar detalhes técnicos, confira a documentação oficial:

• NestJS: https://docs.nestjs.com
  
• TypeORM: https://typeorm.io
  

Se você quer continuar aprendendo e receber mais conteúdos sobre desenvolvimento backend, APIs e boas práticas com Node.js, siga nosso blog e fique por dentro das novidades e tutoriais.

Não deixe de aplicar o que aprendeu hoje: construir APIs robustas e escaláveis é o primeiro passo para projetos profissionais e aplicações que realmente fazem a diferença.