Similar altor framework-uri Node.js, Nest.js oferă un set bogat de instrumente pentru crearea de servicii backend solide și scalabile. Esențial este să înțelegeți cum să implementați eficient operațiunile de creare, citire, actualizare și ștergere (CRUD) în Nest.js, acestea fiind elementele fundamentale în dezvoltarea API-urilor.
Vom explora cum să construim un API CRUD REST în Nest.js folosind TypeORM și o bază de date PostgreSQL.
Începerea lucrului cu Nest.js
Pentru a demara, instalați instrumentul de linie de comandă Nest.js:
npm i -g @nestjs/cli
Apoi, generați un nou proiect executând:
nest new crud-app
Instrumentul CLI vă va cere să alegeți un manager de pachete. Selectați opțiunea preferată. Vom utiliza npm, managerul de pachete Node.
CLI va genera un proiect Nest.js de bază, incluzând toate fișierele de configurare necesare și dependențele inițiale pentru a rula aplicația.
În cele din urmă, accesați directorul proiectului și porniți serverul de dezvoltare.
cd crud-app
npm run start
Codul acestui proiect poate fi găsit în repository-ul său GitHub.
Crearea unei baze de date PostgreSQL
Acest tutorial folosește o instanță PostgreSQL în cloud, dar puteți configura și o bază de date PostgreSQL local. Puteți instala PostgreSQL pe Windows, macOS sau Linux.
Pentru a configura o instanță PostgreSQL în cloud:
Configurarea conexiunii la baza de date
În directorul rădăcină al proiectului, creați un fișier .env și introduceți URL-ul conexiunii la baza de date astfel:
DATABASE_URL="<aici introduceti url-ul conexiunii>"
Acum instalați aceste pachete:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Ulterior, creați un modul pentru baza de date folosind instrumentul CLI.
nest g module database
Deschideți fișierul database/database.module.ts și adăugați următorul cod pentru configurarea bazei de date:
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 {}
Acest modul de bază de date gestionează conexiunea prin configurarea modulului TypeORM cu parametrii de conexiune necesari, în special URL-ul bazei de date.
În plus, definește entitatea „User” ca parte a configurației, specificând structura și proprietățile datelor stocate în tabelul bazei de date PostgreSQL.
În acest stadiu, codul ar putea genera erori, deoarece entitatea „user” nu a fost încă creată. O vom crea în pașii următori.
Actualizarea fișierului app.module.ts
În final, actualizați modulul principal al aplicației pentru a include configurația modulului bazei de date.
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 {}
Definirea unui modul „users”
Modulul „users” servește drept componentă centralizată, responsabilă pentru gestionarea logicii necesare implementării funcționalității CRUD a API-ului.
Executați următoarea comandă în terminal pentru a crea modulul „users” al API-ului.
nest g module users
Instrumentul CLI va actualiza automat fișierul app.module.ts pentru a reflecta modificările efectuate, pe lângă crearea modulului „users”. Acest lucru asigură că noul modul este integrat corect în configurația modulului aplicației.
Crearea unei entități „user”
TypeORM este o bibliotecă ORM (Object-Relational Mapping) care simplifică interacțiunile cu bazele de date în aplicațiile care utilizează TypeScript, prin maparea obiectelor JavaScript la tabelele bazei de date.
Prin crearea unei entități „user” folosind TypeORM, se definește structura și proprietățile datelor utilizatorului în baza de date PostgreSQL.
În directorul „users”, creați un fișier nou model/user.entity.ts și adăugați următorul cod:
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
Entitatea „User” definește structura datelor utilizatorului stocate în baza de date. În acest caz, include id-ul ca o coloană de cheie primară și coloanele pentru nume și e-mail, cu proprietățile corespunzătoare.
Crearea serviciului API CRUD
Acum, creați serviciul API care va gestiona logica operațiunilor CRUD rulând comanda de mai jos:
nest g service users
Deschideți fișierul user-auth.service.ts și adăugați acest cod:
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);
}
}
Această clasă UsersService definește diverse metode API dedicate gestionării operațiunilor CRUD. Aceste metode includ preluarea datelor tuturor utilizatorilor, găsirea unui utilizator specific după ID, crearea unui utilizator nou, actualizarea unui utilizator existent și o metodă de ștergere a datelor unui utilizator din baza de date.
Definirea unui controler pentru API
Creați un controler care va gestiona punctele finale API pentru operațiunile legate de utilizator.
nest g controller users
Apoi, adăugați codul de mai jos în fișierul 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' };
}
}
Controlerul gestionează punctele finale API pentru operațiunile utilizatorului. Se ocupă de cererile GET pentru a prelua toți utilizatorii, cererile POST pentru a crea utilizatori noi, cererile PUT pentru a actualiza utilizatorii existenți și cererile DELETE pentru ștergerea utilizatorilor.
Prin utilizarea UsersService și interacțiunea cu entitatea User, acest controler oferă un API complet pentru gestionarea operațiunilor legate de utilizator pe baza datelor stocate în baza de date.
Actualizarea fișierului users.module.ts
În final, actualizați fișierul users.module.ts așa cum se arată mai jos, pentru a vă asigura că include entitatea „User” și modulul TypeORM, care stabilește conexiunea cu baza de date.
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 {}
În cele din urmă, porniți serverul de dezvoltare pentru a testa operațiunile CRUD folosind Postman.
npm run start
Serverul va porni pe portul 3000 și puteți trimite cereri API la http://localhost:3000/api/users.
Dezvoltarea de aplicații backend cu Nest.js
Indiferent dacă dezvoltați un API REST simplu sau o aplicație web complexă, Nest.js oferă un set amplu de caracteristici și capabilități pentru a construi un sistem backend fiabil și robust.
Nest.js oferă o abordare mai structurată a dezvoltării proiectelor, comparativ cu Express.js. Aceasta asigură că puteți construi, scala și menține cu încredere aplicații complexe, datorită modelului său de design organizat și modular.