Seperti framework Node.js lainnya, Nest.js menyediakan toolkit komprehensif untuk membangun layanan backend yang kuat dan dapat diskalakan. Meskipun demikian, penting untuk memahami cara menerapkan operasi buat, baca, perbarui, dan hapus (CRUD) di Nest.js secara efisien—ini adalah operasi paling mendasar dalam pengembangan API.
Pelajari cara membuat Nest.js CRUD REST API menggunakan TypeORM dan database PostgreSQL.
Daftar isi
Memulai Dengan Nest.js
Untuk memulai, instal alat baris perintah Nest.js:
npm i -g @nestjs/cli
Selanjutnya, buat proyek baru dengan menjalankan:
nest new crud-app
Alat CLI akan meminta Anda untuk memilih manajer paket, pilih opsi yang menurut Anda paling disukai. Kami akan menggunakan npm, manajer paket Node.
CLI akan merancah proyek Nest.js dasar dengan semua file konfigurasi yang diperlukan dan dependensi awal yang diperlukan untuk menjalankan aplikasi.
Terakhir, navigasikan ke direktori proyek dan mulai server pengembangan.
cd crud-app
npm run start
Anda dapat menemukan kode proyek ini di dalamnya GitHub gudang.
Buat Database PostgreSQL
Tutorial ini menggunakan instance cloud PostgreSQL, tetapi Anda dapat menyiapkan database PostgreSQL lokal sebagai gantinya. Anda dapat menginstal PostgreSQL di Windows, di macOS, atau di Linux.
Untuk menyiapkan instance cloud PostgreSQL:
Konfigurasi Koneksi Database
Di direktori root proyek Anda, buat file .env dan rekatkan URL koneksi database sebagai berikut:
DATABASE_URL="<your connection url here>"
Sekarang instal paket-paket ini:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Selanjutnya, lanjutkan dan buat modul database menggunakan alat CLI.
nest g module database
Buka file database/database.module.ts dan tambahkan kode konfigurasi database berikut:
import { Module } from '@nestjs/common';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from '../users/models/user.entity'; @Module({
imports: [
TypeOrmModule.forRootAsync({
imports: [ConfigModule],
inject: [ConfigService],
useFactory: async (configService: ConfigService) => ({
type: 'postgres',
url: configService.get('DATABASE_URL'),
entities: [User],
synchronize: true
}),
}),
],
})
export class DatabaseModule {}
Modul database ini menangani koneksi dengan mengonfigurasi modul TypeORM dengan parameter koneksi yang diperlukan, URL database.
Selain itu, ia mendefinisikan entitas Pengguna sebagai bagian dari konfigurasi yang menentukan struktur dan properti data yang disimpan dalam tabel database PostgreSQL.
Pada tahap ini, kode Anda mungkin akan menimbulkan kesalahan karena Anda belum membuat entitas pengguna. Anda akan melakukannya dalam langkah-langkah berikut.
Perbarui File app.module.ts
Terakhir, perbarui modul aplikasi utama untuk memasukkan konfigurasi modul database.
import { Module } from '@nestjs/common';
import { ConfigModule } from '@nestjs/config';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { DatabaseModule } from './database/database.module';@Module({
imports: [
ConfigModule.forRoot({
envFilePath: '.env',
}),
DatabaseModule,
],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
Tentukan Modul Pengguna
Modul pengguna berfungsi sebagai komponen terpusat, bertanggung jawab untuk mengenkapsulasi dan mengelola logika yang diperlukan untuk mengimplementasikan fungsionalitas CRUD API.
Jalankan perintah terminal ini untuk membuat modul pengguna API.
nest g module users
Alat CLI secara otomatis memperbarui file app.module.ts untuk mencerminkan perubahan yang dilakukan, selain membuat modul pengguna. Ini memastikan bahwa modul yang baru dibuat, pengguna, diintegrasikan dengan benar ke dalam konfigurasi modul aplikasi.
Buat Entitas Pengguna
TypeORM adalah pustaka Object-Relational Mapping (ORM) yang menyederhanakan interaksi database dalam aplikasi yang menggunakan TypeScript dengan memetakan objek JavaScript ke tabel database.
Dengan membuat entitas Pengguna menggunakan TypeORM, Anda menentukan struktur dan properti data pengguna di database PostgreSQL.
Di direktori users, buat model/user.entity.ts baru dan tambahkan kode berikut.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
Entitas Pengguna mendefinisikan struktur data pengguna yang disimpan dalam database. Dalam hal ini, itu adalah id sebagai kolom kunci utama, dan kolom nama dan email serta properti yang sesuai.
Buat Layanan CRUD API
Sekarang, buat layanan API yang akan mengelola logika untuk operasi CRUD dengan menjalankan perintah di bawah ini:
nest g service users
Buka file user-auth.service.ts dan tambahkan kode ini:
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import {User} from './models/user.entity';@Injectable()
export class UsersService {
constructor(
@InjectRepository(User)
private userRepository: Repository<User>,
) {}
async findAll(): Promise<User[]> {
return this.userRepository.find();
}
async findOne(id: number): Promise<User> {
return this.userRepository.findOne({ where: { id } });
}
async create(user: Partial<User>): Promise<User> {
const newuser = this.userRepository.create(user);
return this.userRepository.save(newuser);
}
async update(id: number, user: Partial<User>): Promise<User> {
await this.userRepository.update(id, user);
return this.userRepository.findOne({ where: { id } });
}
async delete(id: number): Promise<void> {
await this.userRepository.delete(id);
}
}
Kelas UsersService ini mendefinisikan berbagai metode API yang didedikasikan untuk menangani operasi CRUD. Metode ini termasuk mengambil semua data pengguna, menemukan pengguna tertentu menggunakan nomor ID mereka, membuat pengguna baru, memperbarui pengguna yang ada, dan metode untuk menghapus data pengguna tertentu di database.
Tentukan Pengontrol untuk API
Buat pengontrol yang akan mengelola titik akhir API untuk operasi terkait pengguna.
nest g controller users
Selanjutnya, tambahkan kode di bawah ini ke file users.controller.ts.
import { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './models/user.entity';@Controller('api/users')
export class UsersController {
constructor(private readonly usersService: UsersService) {}
@Get()
async findAll(): Promise<User[]> {
return this.usersService.findAll();
}
@Post()
@HttpCode(201)
async create(@Body() user: User): Promise<User> {
const createdUser = await this.usersService.create(user);
return createdUser;
}
@Put(':id')
async update (@Param('id') id: number, @Body() user: User): Promise<any> {
await this.usersService.update(id, user);
return { message: 'User updated successfully' };
}
@Delete(':id')
async delete(@Param('id') id: number): Promise<any> {
const user = await this.usersService.findOne(id);
if (!user) {
throw new NotFoundException('User does not exist!');
}
await this.usersService.delete(id);
return { message: 'User deleted successfully' };
}
}
Pengontrol mengelola titik akhir API untuk operasi pengguna. Ini menangani permintaan GET untuk mengambil semua pengguna, permintaan POST untuk membuat pengguna baru, permintaan PUT untuk memperbarui pengguna yang ada, dan permintaan DELETE untuk menghapus pengguna.
Dengan memanfaatkan Layanan Pengguna dan berinteraksi dengan entitas Pengguna, pengontrol ini menyediakan API lengkap untuk mengelola operasi terkait pengguna pada data yang disimpan dalam database.
Perbarui File users.module.ts
Terakhir, perbarui file users.module.ts seperti yang ditunjukkan di bawah ini untuk memastikan Anda memasukkan entitas Pengguna dan modul TypeORM, yang membuat koneksi ke database.
import { Module } from '@nestjs/common';
import { UsersController } from './users.controller';
import { UsersService } from './users.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './models/user.entity';@Module({
imports: [TypeOrmModule.forFeature([User])],
controllers: [UsersController],
providers: [UsersService]
})
export class UsersModule {}
Terakhir, lanjutkan, dan nyalakan server pengembangan untuk menguji operasi CRUD menggunakan Postman.
npm run start
Server akan dimulai pada port 3000, dan Anda dapat mengirim permintaan API ke sana di http://localhost:3000/api/pengguna.
Membangun Aplikasi Backend Dengan Nest.js
Apakah Anda sedang mengembangkan REST API sederhana atau aplikasi web yang kompleks, Nest.js menawarkan serangkaian fitur dan kemampuan yang komprehensif untuk membuat sistem backend yang andal dan tangguh.
Nest.js menawarkan pendekatan yang lebih terstruktur untuk pengembangan proyek daripada Express.js. Hal ini memastikan bahwa Anda dapat membangun, menskalakan, dan memelihara aplikasi kompleks dengan percaya diri, berkat pola desain modular dan teraturnya.
