Más Node.js-keretrendszerekhez hasonlóan a Nest.js is átfogó eszközkészletet kínál robusztus és méretezhető háttérszolgáltatások létrehozásához. Mindazonáltal fontos megérteni, hogyan lehet hatékonyan megvalósítani a létrehozási, olvasási, frissítési és törlési (CRUD) műveleteket a Nest.js-ben – ezek a legalapvetőbb műveletek az API-k fejlesztésében.
Ismerje meg, hogyan hozhat létre Nest.js CRUD REST API-t TypeORM és PostgreSQL adatbázis használatával.
Tartalomjegyzék
A Nest.js használatának megkezdése
A kezdéshez telepítse a Nest.js parancssori eszközt:
npm i -g @nestjs/cli
Ezután hozzon létre egy új projektet a következő futtatással:
nest new crud-app
A CLI eszköz felkéri Önt, hogy válasszon csomagkezelőt, és válassza ki a legkedvezőbb opciót. Az npm-et, a Node csomagkezelőt fogjuk használni.
A CLI egy alap Nest.js projektet hoz létre az alkalmazás futtatásához szükséges összes konfigurációs fájllal és kezdeti függőséggel.
Végül keresse meg a projektkönyvtárat, és indítsa el a fejlesztőkiszolgálót.
cd crud-app
npm run start
A projekt kódja megtalálható benne GitHub adattár.
Hozzon létre egy PostgreSQL adatbázist
Ez az oktatóanyag felhőalapú PostgreSQL-példányt használ, de beállíthat helyette egy helyi PostgreSQL-adatbázist. A PostgreSQL-t Windowsra, macOS-re vagy Linuxra telepítheti.
Felhőbeli PostgreSQL-példány beállítása:
Állítsa be az adatbázis-kapcsolatot
A projekt gyökérkönyvtárában hozzon létre egy .env fájlt, és illessze be az adatbázis-kapcsolat URL-címét az alábbiak szerint:
DATABASE_URL="<your connection url here>"
Most telepítse ezeket a csomagokat:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Ezután folytassa és hozzon létre egy adatbázis-modult a CLI eszközzel.
nest g module database
Nyissa meg az adatbázis/database.module.t fájlt, és adja hozzá a következő adatbázis-konfigurációs kódot:
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 {}
Ez az adatbázismodul úgy kezeli a kapcsolatot, hogy beállítja a TypeORM modult a szükséges kapcsolati paraméterrel, az adatbázis URL-címével.
Ezenkívül meghatározza a User entitást a konfiguráció részeként, amely meghatározza a PostgreSQL adatbázistáblában tárolt adatok szerkezetét és tulajdonságait.
Ebben a szakaszban a kód valószínűleg hibát fog kiütni, mert még nem hozta létre a felhasználók entitást. Ezt a következő lépésekben teheti meg.
Frissítse az app.module.ts fájlt
Végül frissítse a fő alkalmazásmodult, hogy tartalmazza az adatbázis-modul konfigurációját.
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 {}
Határozzon meg egy felhasználói modult
A felhasználói modul központi komponensként szolgál, amely az API CRUD funkcióinak megvalósításához szükséges logika beágyazásáért és kezeléséért felelős.
Futtassa ezt a terminálparancsot az API felhasználói moduljának létrehozásához.
nest g module users
A CLI eszköz a felhasználói modul létrehozása mellett automatikusan frissíti az app.module.ts fájlt, hogy tükrözze a végrehajtott változtatásokat. Ez biztosítja, hogy az újonnan létrehozott modul, a felhasználók megfelelően integrálódjanak az alkalmazás modulkonfigurációjába.
Hozzon létre egy felhasználói entitást
A TypeORM egy objektum-relációs leképezési (ORM) könyvtár, amely leegyszerűsíti az adatbázis-interakciókat a TypeScriptet használó alkalmazásokban azáltal, hogy JavaScript-objektumokat képez adatbázistáblákhoz.
A TypeORM használatával felhasználói entitás létrehozásával meghatározhatja a felhasználói adatok szerkezetét és tulajdonságait a PostgreSQL adatbázisban.
A felhasználók könyvtárában hozzon létre egy új models/user.entity.ts fájlt, és adja hozzá a következő kódot.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
A Felhasználó entitás határozza meg az adatbázisban tárolt felhasználói adatok szerkezetét. Ebben az esetben ez az azonosító, mint az elsődleges kulcs oszlopa, valamint a név és e-mail oszlopok, valamint a hozzájuk tartozó tulajdonságok.
Hozza létre a CRUD API szolgáltatást
Most hozza létre az API-szolgáltatást, amely kezeli a CRUD műveletek logikáját az alábbi parancs futtatásával:
nest g service users
Nyissa meg a user-auth.service.ts fájlt, és adja hozzá ezt a kódot:
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);
}
}
Ez a UsersService osztály különféle API-metódusokat határoz meg a CRUD műveletek kezelésére. Ezek a módszerek magukban foglalják az összes felhasználó adatának lekérését, egy adott felhasználó megtalálását az azonosítószámával, új felhasználó létrehozását, egy meglévő felhasználó frissítését, valamint egy adott felhasználó adatainak adatbázisból való törlését.
Határozzon meg egy vezérlőt az API-hoz
Hozzon létre egy vezérlőt, amely kezeli a felhasználókkal kapcsolatos műveletek API-végpontjait.
nest g controller users
Ezután adja hozzá az alábbi kódot a users.controller.ts fájlhoz.
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' };
}
}
A vezérlő kezeli a felhasználói műveletek API-végpontjait. Kezeli a GET kéréseket az összes felhasználó lekéréséhez, a POST kéréseket új felhasználók létrehozásához, a PUT kéréseket a meglévő felhasználók frissítéséhez és a DELETE kéréseket a felhasználók törléséhez.
A UsersService használatával és a felhasználói entitással való interakció révén ez a vezérlő teljes API-t biztosít az adatbázisban tárolt adatok felhasználóval kapcsolatos műveleteinek kezelésére.
Frissítse a users.module.ts fájlt
Végül frissítse a users.module.ts fájlt az alábbiak szerint, hogy biztosítsa a felhasználói entitás és a TypeORM modul beépítését, amely létrehozza a kapcsolatot az adatbázissal.
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 {}
Végül folytassa a fejlesztői kiszolgáló felpörgetésével, hogy tesztelje a CRUD-műveleteket a Postman segítségével.
npm run start
A szerver a 3000-es porton indul, és API kéréseket küldhet neki a címen http://localhost:3000/api/users.
Háttéralkalmazások létrehozása a Nest.js segítségével
Akár egyszerű REST API-t, akár összetett webalkalmazást fejleszt, a Nest.js funkciók és képességek átfogó készletét kínálja megbízható és robusztus háttérrendszer felépítéséhez.
A Nest.js strukturáltabb megközelítést kínál a projektfejlesztéshez, mint az Express.js. Ez biztosítja, hogy a szervezett és moduláris tervezési mintának köszönhetően magabiztosan építhet, méretezhet és karbantarthat összetett alkalmazásokat.