Ca și alte cadre Node.js, Nest.js oferă un set de instrumente cuprinzător pentru construirea de servicii backend robuste și scalabile. Cu toate acestea, este important să înțelegeți cum să implementați eficient operațiunile de creare, citire, actualizare și ștergere (CRUD) în Nest.js – acestea sunt cele mai fundamentale operațiuni în dezvoltarea API-urilor.
Aflați cum să creați un API CRUD REST Nest.js folosind TypeORM și o bază de date PostgreSQL.
Cuprins
Noțiuni introductive cu Nest.js
Pentru a începe, instalați instrumentul de linie de comandă Nest.js:
npm i -g @nestjs/cli
Apoi, creați un nou proiect rulând:
nest new crud-app
Instrumentul CLI vă va solicita să alegeți un manager de pachete, să alegeți opțiunea pe care o considerați cea mai preferată. Vom folosi npm, managerul de pachete Node.
CLI va schelă un proiect Nest.js de bază cu toate fișierele de configurare necesare și dependențele inițiale necesare pentru a rula aplicația.
În cele din urmă, navigați la directorul de proiect și porniți serverul de dezvoltare.
cd crud-app
npm run start
Puteți găsi codul acestui proiect în documentul său GitHub repertoriu.
Creați o bază de date PostgreSQL
Acest tutorial folosește o instanță PostgreSQL în cloud, dar puteți configura o bază de date locală PostgreSQL. Puteți instala PostgreSQL pe Windows, pe macOS sau pe Linux.
Pentru a configura o instanță PostgreSQL în cloud:
Configurați conexiunea la baza de date
În directorul rădăcină al proiectului, creați un fișier .env și inserați adresa URL a conexiunii la baza de date după cum urmează:
DATABASE_URL="<your connection url here>"
Acum instalați aceste pachete:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Apoi, continuați și creați un modul de bază de date folosind instrumentul CLI.
nest g module database
Deschideți fișierul database/database.module.ts și adăugați următorul cod de configurare a 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 parametrul de conexiune necesar, adresa URL a bazei de date.
În plus, definește entitatea Utilizator ca parte a configurației care specifică structura și proprietățile datelor stocate în tabelul bazei de date PostgreSQL.
În această etapă, codul dvs. va genera probabil o eroare deoarece nu ați creat încă entitatea utilizatorilor. Veți face asta în următorii pași.
Actualizați fișierul app.module.ts
În cele din urmă, actualizați modulul principal al aplicației pentru a include configurația pentru modulul 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 {}
Definiți un modul de utilizatori
Modulul utilizatori servește ca o componentă centralizată, responsabilă pentru încapsularea și gestionarea logicii necesare implementării funcționalității CRUD a API-ului.
Rulați această comandă de terminal pentru a crea modulul utilizatori al API-ului.
nest g module users
Instrumentul CLI actualizează automat fișierul app.module.ts pentru a reflecta modificările efectuate, pe lângă crearea modulului utilizator. Acest lucru asigură că modulul nou creat, utilizatorii, este integrat corespunzător în configurația modulului aplicației.
Creați o entitate utilizator
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 utilizator folosind TypeORM, definiți structura și proprietățile datelor utilizatorului din baza de date PostgreSQL.
În directorul utilizatorilor, creați un model nou/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 utilizator stocate în baza de date. În acest caz, acesta este id-ul ca coloană a cheii primare și coloanele cu nume și e-mail și proprietățile corespunzătoare.
Creați serviciul 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 diferite metode API dedicate gestionării operațiunilor CRUD. Aceste metode includ preluarea datelor tuturor utilizatorilor, găsirea unui anumit utilizator folosind numărul său de identificare, crearea unui utilizator nou, actualizarea unui utilizator existent și o metodă de ștergere a datelor unui anumit utilizator din baza de date.
Definiți un 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 solicitările GET pentru a prelua toți utilizatorii, solicitările POST pentru a crea utilizatori noi, solicitările PUT pentru a actualiza utilizatorii existenți și solicitările DELETE pentru ștergerea utilizatorilor.
Prin utilizarea UsersService și interacțiunea cu entitatea Utilizator, acest controlor oferă un API complet pentru gestionarea operațiunilor legate de utilizator cu privire la datele stocate în baza de date.
Actualizați fișierul users.module.ts
În cele din urmă, actualizați fișierul users.module.ts așa cum se arată mai jos pentru a vă asigura că includeți entitatea User și modulul TypeORM, care stabilește conexiunea la 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ă, mergeți mai departe și porniți serverul de dezvoltare pentru a testa operațiunile CRUD folosind Postman.
npm run start
Serverul va porni pe portul 3000 și îi puteți trimite cereri API la http://localhost:3000/api/users.
Crearea 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 cuprinzător 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 decât Express.js. Acest lucru vă asigură că puteți construi, scala și menține cu încredere aplicații complexe, datorită modelului său de design organizat și modular.