Cómo Configurar un Proyecto NestJS + MySQL + TypeScript

  • 604Palabras
  • 3Minutos
  • 05 Jul, 2024

Este artículo explica detalladamente cómo configurar un proyecto NestJS + MySQL + TypeScript desde cero, ayudando a los desarrolladores a comenzar rápidamente y construir sus propios proyectos.

Inicialización del Proyecto

Primero, necesitamos instalar globalmente Nest CLI:

Terminal window
1
npm install -g @nestjs/cli

Luego, utilizamos Nest CLI para crear un nuevo proyecto:

Terminal window
1
nest new my-nestjs-project

Elige npm o yarn como la herramienta de gestión de paquetes y sigue las indicaciones para completar la inicialización del proyecto.

Instalación de Dependencias Necesarias

A continuación, entra en el directorio del proyecto e instala las dependencias necesarias:

Terminal window
1
cd my-nestjs-project
2
npm install --save @nestjs/typeorm typeorm mysql2
3
npm install --save-dev @types/mysql2

Aquí instalamos los paquetes @nestjs/typeorm, typeorm y mysql2, así como sus archivos de definición de tipos.

Creación de Módulo, Controlador y Servicio

A continuación, utilizamos Nest CLI para generar un módulo de usuario:

Terminal window
1
nest generate module users
2
nest generate controller users
3
nest generate service users

Crea una entidad de usuario, añadiendo lo siguiente en src/users/user.entity.ts:

1
import { Entity, Column, PrimaryGeneratedColumn } from "typeorm";
2


3
@Entity()
4
export class User {
5
  @PrimaryGeneratedColumn()
6
  id: number;
7


8
  @Column()
9
  name: string;
10


11
  @Column()
12
  email: string;
13
}

En src/users/users.module.ts, importa la entidad User:

1
import { Module } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { UsersService } from "./users.service";
4
import { UsersController } from "./users.controller";
5
import { User } from "./user.entity";
6


7
@Module({
8
  imports: [TypeOrmModule.forFeature([User])],
9
  providers: [UsersService],
10
  controllers: [UsersController],
11
})
12
export class UsersModule {}

Implementación de Operaciones CRUD

En src/users/users.service.ts, implementa las operaciones CRUD:

1
import { Injectable } from "@nestjs/common";
2
import { InjectRepository } from "@nestjs/typeorm";
3
import { Repository } from "typeorm";
4
import { User } from "./user.entity";
5


6
@Injectable()
7
export class UsersService {
8
  constructor(
9
    @InjectRepository(User)
10
    private usersRepository: Repository<User>,
11
  ) {}
12


13
  findAll(): Promise<User[]> {
14
    return this.usersRepository.find();
15
  }
16


17
  findOne(id: number): Promise<User> {
18
    return this.usersRepository.findOneBy({ id });
19
  }
20


21
  create(user: User): Promise<User> {
22
    return this.usersRepository.save(user);
23
  }
24


25
  async update(id: number, user: User): Promise<void> {
26
    await this.usersRepository.update(id, user);
27
  }
28


29
  async remove(id: number): Promise<void> {
30
    await this.usersRepository.delete(id);
31
  }
32
}

En src/users/users.controller.ts, define las rutas:

1
import {
2
  Controller,
3
  Get,
4
  Post,
5
  Body,
6
  Param,
7
  Delete,
8
  Put,
9
} from "@nestjs/common";
10
import { UsersService } from "./users.service";
11
import { User } from "./user.entity";
12


13
@Controller("users")
14
export class UsersController {
15
  constructor(private readonly usersService: UsersService) {}
16


17
  @Get()
18
  findAll(): Promise<User[]> {
19
    return this.usersService.findAll();
20
  }
21


22
  @Get(":id")
23
  findOne(@Param("id") id: number): Promise<User> {
24
    return this.usersService.findOne(id);
25
  }
26


27
  @Post()
28
  create(@Body() user: User): Promise<User> {
29
    return this.usersService.create(user);
30
  }
31


32
  @Put(":id")
33
  update(@Param("id") id: number, @Body() user: User): Promise<void> {
34
    return this.usersService.update(id, user);
35
  }
36


37
  @Delete(":id")
38
  remove(@Param("id") id: number): Promise<void> {
39
    return this.usersService.remove(id);
40
  }
41
}

Luego, en src/app.module.ts, configura el módulo TypeORM:

1
import { Module } from "@nestjs/common";
2
import { TypeOrmModule } from "@nestjs/typeorm";
3
import { AppController } from "./app.controller";
4
import { AppService } from "./app.service";
5
import { UsersModule } from "./users/users.module";
6
import { User } from "./users/user.entity";
7


8
@Module({
9
  imports: [
10
    TypeOrmModule.forRoot({
11
      type: "mysql",
12
      host: "localhost",
13
      port: 3306,
14
      username: "root",
15
      password: "password",
16
      database: "test",
17
      entities: [User],
18
      synchronize: true,
19
    }),
20
    UsersModule,
21
  ],
22
  controllers: [AppController],
23
  providers: [AppService],
24
})
25
export class AppModule {}

Nota: en un entorno de producción, se recomienda configurar synchronize a false para evitar el riesgo de pérdida de datos.

Estructura del Proyecto

La estructura del proyecto debería parecerse a:

1
my-nestjs-project
2
├── src
3
│   ├── app.controller.ts
4
│   ├── app.module.ts
5
│   ├── app.service.ts
6
│   ├── main.ts
7
│   └── users
8
│       ├── user.entity.ts
9
│       ├── users.controller.ts
10
│       ├── users.module.ts
11
│       └── users.service.ts
12
├── test
13
├── .gitignore
14
├── nest-cli.json
15
├── ormconfig.json
16
├── package.json
17
├── README.md
18
├── tsconfig.build.json
19
└── tsconfig.json

Iniciar el Proyecto

Usa el siguiente comando para iniciar el proyecto:

Terminal window
1
npm run start

Por defecto, el proyecto de NestJS se ejecutará en http://localhost:3000. Puedes acceder a esta dirección y usar Postman u otras herramientas para probar los endpoints de la API.

Conclusión

Este artículo detalla cómo configurar un proyecto NestJS + MySQL + TypeScript desde cero, incluyendo la inicialización del proyecto, instalación de dependencias, configuración de TypeORM, creación de módulos e implementación de operaciones CRUD.

Artículos similares

Cómo Diferenciar el Entorno de Desarrollo y el Entorno de Producción y su Configuración (NestJS + MySQL + TypeScript)

Cómo Diferenciar el Entorno de Desarrollo y el Entorno de Producción y su Configuración (NestJS + MySQL + TypeScript)

Explicación Detallada del Controlador de NestJS: Manejo de Diferentes Métodos de Solicitud HTTP y Parámetros de Ruta

Explicación Detallada del Controlador de NestJS: Manejo de Diferentes Métodos de Solicitud HTTP y Parámetros de Ruta