Nest.js CRUD REST API loomine TypeORM-i ja PostgreSQL-i abil

Nagu teisedki Node.js-i raamistikud, pakub Nest.js terviklikku tööriistakomplekti tugevate ja skaleeritavate taustateenuste loomiseks. Sellegipoolest on oluline mõista, kuidas luua, lugeda, värskendada ja kustutada (CRUD) toimingud Nest.js-is tõhusalt – need on arenduse kõige olulisemad toimingud API-dest.

Siit saate teada, kuidas luua Nest.js CRUD REST API, kasutades TypeORM-i ja PostgreSQL-i andmebaasi.

Nest.js-iga alustamine

Alustamiseks installige käsureatööriist Nest.js.

npm i -g @nestjs/cli

Järgmisena looge uus projekt, käivitades:

nest uus crud-rakendus

CLI tööriist palub teil valida paketihalduri ja valida kõige eelistatavama valiku. Me kasutame npm, sõlme paketihaldur.

CLI loob põhiprojekti Nest.js koos kõigi nõutavate konfiguratsioonifailide ja esialgsete sõltuvustega, mis on vajalikud rakenduse käitamiseks.

Lõpuks liikuge projektikataloogi ja käivitage arendusserver.

cd crud-app
npm jooksu algus

Selle projekti koodi leiate sellest GitHub hoidla.

Looge PostgreSQL-i andmebaas

See õpetus kasutab PostgreSQL-i pilveeksemplari, kuid selle asemel saate seadistada kohaliku PostgreSQL-i andmebaasi. Sa saad installige PostgreSQL Windowsi, macOS-is, või Linuxis.

Pilve PostgreSQL-i eksemplari seadistamiseks tehke järgmist.

1. Suunduge poole ElephantSQL, registreeruge ja logige sisse oma konto ülevaatelehele.
2. Klõpsake nuppu Looge uus eksemplar lehe vasakus ülanurgas olevat nuppu, et luua oma rakendusele uus eksemplar.
3. Sisestage oma eksemplari nimi, valige tasuta pakett ja lõpuks valige seadistusprotsessi lõpuleviimiseks piirkond.
4. Pärast andmebaasi eksemplari loomist minge lehele seaded leht ja kopeerige pakutav andmebaasi URL.

Andmebaasiühenduse konfigureerimine

Looge oma projekti juurkataloogis a .env fail ja kleepige andmebaasi ühenduse URL järgmiselt:

DATABASE_URL=""

Nüüd installige need paketid:

npm installige pg typeorm @nestjs/typeorm @nestjs/config

Järgmisena looge CLI tööriista abil andmebaasimoodul.

nest g mooduli andmebaas

Ava andmebaas/andmebaas.moodul.ts faili ja lisage järgmine andmebaasi konfiguratsioonikood:

importida { Moodul } alates„@nestjs/common”;
importida { ConfigModule, ConfigService } alates'@nestjs/config';
importida { TypeOrmModule } alates'@nestjs/typeorm';
importida { Kasutaja } alates"../users/models/user.entity"; 
@Moodul({
 import: [
 TypeOrmModule.forRootAsync({
 impordib: [ConfigModule], 
 süstige: [ConfigService],
 useFactory: asünkr (configService: ConfigService) => ({
tüüp: 'postgres',
 url: configService.get('DATABASE_URL'), 
 üksused: [kasutaja],
 sünkroonida: tõsi
 }),
 }),
 ],
})
eksportidaklass Andmebaasimoodul {}

See andmebaasimoodul haldab ühendust, konfigureerides mooduli TypeORM nõutava ühenduse parameetriga, andmebaasi URL-iga.

Lisaks määratleb see kasutaja olemi osana konfiguratsioonist, mis määrab PostgreSQL-i andmebaasi tabelisse salvestatud andmete struktuuri ja atribuudid.

Selles etapis annab teie kood tõenäoliselt vea, kuna te pole veel kasutajate olemit loonud. Teete seda järgmiste sammudega.

Värskendage faili app.module.ts

Lõpuks värskendage põhirakenduse moodulit, et lisada andmebaasimooduli konfiguratsioon.

importida { Moodul } alates„@nestjs/common”;
importida { ConfigModule } alates'@nestjs/config';
importida { AppController } alates'./app.controller';
importida { AppService } alates'./app.service';
importida { DatabaseModule } alates'./database/database.module';
@Moodul({
 import: [
 ConfigModule.forRoot({
 envFilePath: ".env", 
 }),
 Andmebaasimoodul,
 ],
 kontrollerid: [AppController],
 pakkujad: [AppService],
})
eksportidaklass AppModule {}

Määratlege kasutajate moodul

Kasutajate moodul toimib tsentraliseeritud komponendina, mis vastutab API CRUD-funktsiooni rakendamiseks vajaliku loogika kapseldamise ja haldamise eest.

Käivitage see terminalikäsk API kasutajate mooduli loomiseks.

nest g mooduli kasutajad

CLI tööriist värskendab automaatselt app.module.ts faili, et kajastada tehtud muudatusi, lisaks kasutajamooduli loomisele. See tagab, et vastloodud moodul, kasutajad, on korralikult rakenduse mooduli konfiguratsiooniga integreeritud.

Looge kasutaja olem

TypeORM on Object-Relational Mapping (ORM) teek, mis lihtsustab andmebaasi interaktsioone rakendustes, mis kasutavad TypeScripti, vastendades JavaScripti objektid andmebaasi tabelitega.

TypeORM-i abil kasutaja olemi loomisel määrate PostgreSQL-i andmebaasis kasutajaandmete struktuuri ja atribuudid.

Looge kasutajate kataloogis uus mudelid/user.entity.ts ja lisage järgmine kood.

importida { Entity, PrimaryGeneratedColumn, Column, } alates"tüüpvorm";
@Entity()
eksportidaklass kasutaja {
@PrimaryGeneratedColumn()
 id: number;
@Veerg()
 nimi: string;
@Veerg()
 email: string;
}

The Kasutaja olem määratleb andmebaasis salvestatud kasutajaandmete struktuuri. Sel juhul on see id primaarvõtme veeruna ja nimi ja meili veerud ja nende vastavad omadused.

Looge CRUD API teenus

Nüüd looge API-teenus, mis haldab CRUD-i toimingute loogikat, käivitades alloleva käsu:

nest g teenuse kasutajad

Ava user-auth.service.ts faili ja lisage see kood:

importida { Süstitav } alates„@nestjs/common”;
importida { InjectRepository } alates'@nestjs/typeorm';
importida { Hoidla } alates"tüüpvorm";
importida {kasutaja} alates'./models/user.entity';
@Süstitav()
eksportidaklass UsersService {
konstruktor(
@InjectRepository(kasutaja)
privaatne userRepository: hoidla,
 ) {}
asünkr leia kõik(): Lubadus {
tagasisee.userRepository.find();
 }
asünkr findOne (id: number): Lubadus {
tagasisee.userRepository.findOne({ kus: { id } });
 }
asünkr loo (kasutaja: osaline): Lubadus {
konst uuskasutaja = see.userRepository.create (kasutaja);
tagasisee.userRepository.save (uuskasutaja);
 }
asünkr värskendus (id: number, kasutaja: Osaline): Lubadus {
ootamasee.userRepository.update (id, kasutaja);
tagasisee.userRepository.findOne({ kus: { id } });
 }
asünkrkustutada(id: number): Lubadus<tühine> {
ootamasee.userRepository.delete (id);
 }
}

See UsersService klass määratleb erinevad API meetodid, mis on pühendatud CRUD toimingute käitlemisele. Need meetodid hõlmavad kõigi kasutajate andmete toomist, konkreetse kasutaja leidmist tema ID-numbri abil, loomist uus kasutaja, olemasoleva kasutaja uuendamine ja meetod konkreetse kasutaja andmete kustutamiseks andmebaasist.

Määrake API jaoks kontroller

Looge kontroller, mis haldab kasutajaga seotud toimingute API lõpp-punkte.

nest g kontrolleri kasutajad

Järgmisena lisage allolev kood users.controller.ts faili.

importida { Kontroller, Hangi, Postita, Keha, Pane, Parameeter, Kustuta, NotFoundException, HttpCode } alates„@nestjs/common”;
importida { UsersService } alates'./users.service';
importida { Kasutaja } alates'./models/user.entity';
@Controller('api/kasutajad')
eksportidaklass UsersController {
konstruktor(privaatne readonly usersService: UsersService) {}
@Hangi()
asünkr leia kõik(): Lubadus {
tagasisee.usersService.findAll();
 }
@Postitus()
@HttpCode(201) 
asünkr loo(@Keha() kasutaja: Kasutaja): Lubadus {
konst loodudKasutaja = ootamasee.usersService.create (kasutaja);
tagasi loodudKasutaja;
 }
@Put(':id')
asünkr värskenda (@Param('id') id: number, @Keha() kasutaja: Kasutaja): Lubadus<ükskõik milline> {
ootamasee.usersService.update (id, kasutaja);
tagasi { sõnum: "Kasutaja värskendamine õnnestus" };
 }
@Kustuta(':id')
asünkrkustutada(@Param('id') id: number): Lubadus<ükskõik milline> {
konst kasutaja = ootamasee.usersService.findOne (id);
kui (!kasutaja) {
viskamauus NotFoundException('Kasutajat pole olemas!');
 }
ootamasee.usersService.delete (id);
tagasi { sõnum: "Kasutaja kustutati edukalt" };
 }
}

Kontroller haldab kasutaja toimingute API lõpp-punkte. See käsitleb GET-i taotlusi kõigi kasutajate toomiseks, POST-i taotlusi uute kasutajate loomiseks, PUT-taotlusi olemasolevate kasutajate värskendamiseks ja DELETE-taotlusi kasutajate kustutamiseks.

Kasutades Kasutajate teenus ja suhtlemine Kasutaja olem, pakub see kontroller täielikku API-d kasutajaga seotud toimingute haldamiseks andmebaasi salvestatud andmetega.

Värskendage faili users.module.ts

Lõpuks värskendage users.module.ts faili, nagu allpool näidatud, et tagada selle lisamine Kasutaja olem ja TypeORM moodul, mis loob ühenduse andmebaasiga.

importida { Moodul } alates„@nestjs/common”;
importida { UsersController } alates'./users.controller';
importida { UsersService } alates'./users.service';
importida { TypeOrmModule } alates'@nestjs/typeorm';
importida { Kasutaja } alates'./models/user.entity';
@Moodul({
 impordid: [TypeOrmModule.forFeature([User])],
 kontrollerid: [UsersController],
 pakkujad: [UsersService]
})
eksportidaklass Kasutajate moodul {}

Lõpuks minge edasi ja käivitage arendusserver, et testida CRUD-i toiminguid Postmani abil.

npm jooksu algus

Server käivitub pordist 3000 ja saate saata sellele API päringuid aadressil http://localhost: 3000 / api / kasutajad.

Taustarakenduste loomine Nest.js-iga

Olenemata sellest, kas arendate lihtsat REST API-t või keerukat veebirakendust, pakub Nest.js laia valikut funktsioone ja võimalusi usaldusväärse ja töökindla taustasüsteemi loomiseks.

Nest.js pakub projektiarendusele struktureeritumat lähenemist kui Express.js. See tagab, et saate tänu organiseeritud ja modulaarsele disainimustrile enesekindlalt ehitada, skaleerida ja hooldada keerulisi rakendusi.