How to Set Up a NestJS + MySQL + TypeScript Project

This article provides a detailed guide on how to set up a NestJS + MySQL + TypeScript project from scratch to help you quickly get started and build your own project.

Project Initialization

First, we need to globally install the Nest CLI:

Terminal window
1
npm install -g @nestjs/cli

Then, create a new project using the Nest CLI:

Terminal window
1
nest new my-nestjs-project

Choose npm or yarn as your package manager and follow the prompts to complete the project initialization.

Install Necessary Dependencies

Next, enter the project directory and install the necessary dependencies:

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

Here we install the @nestjs/typeorm, typeorm, and mysql2 packages along with their type definitions.

Create Modules, Controllers, and Services

Next, generate a user module using the Nest CLI:

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

Create a User entity and add the following content in 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
}

Import the User entity in src/users/users.module.ts:

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 {}

Implement CRUD Operations

Implement CRUD operations in src/users/users.service.ts:

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
}

Define routes in src/users/users.controller.ts:

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
}

Then, configure the TypeORM module in src/app.module.ts:

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 {}

Note: It is recommended to set synchronize to false in a production environment to avoid data loss risks.

Project Directory Structure

The project directory structure should look like this:

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

Start the Project

Start the project using the following command:

Terminal window
1
npm run start

By default, the NestJS project will run at http://localhost:3000. You can test the API endpoints by visiting this address and using Postman or other tools.

Conclusion

This article provides a detailed guide on how to set up a NestJS + MySQL + TypeScript project from scratch, including project initialization, installing dependencies, configuring TypeORM, creating modules, and implementing CRUD operations.

Similar Posts

How to Distinguish and Configure Development and Production Environments (NestJS + MySQL + TypeScript)

How to Distinguish and Configure Development and Production Environments (NestJS + MySQL + TypeScript)

Detailed Explanation of NestJS Controllers: Handling Different HTTP Request Methods and Route Parameters

Detailed Explanation of NestJS Controllers: Handling Different HTTP Request Methods and Route Parameters