Kā izveidot Nest.js CRUD REST API, izmantojot TypeORM un PostgreSQL

Tāpat kā citi Node.js ietvari, Nest.js nodrošina visaptverošu rīku komplektu stabilu un mērogojamu aizmugursistēmas pakalpojumu izveidei. Tomēr ir svarīgi saprast, kā ieviest izveidi, lasīšanu, atjaunināšanu un dzēšanu (CRUD) operācijas pakalpojumā Nest.js — šīs ir vissvarīgākās izstrādes darbības API.

Uzziniet, kā izveidot Nest.js CRUD REST API, izmantojot TypeORM un PostgreSQL datu bāzi.

Darba sākšana ar Nest.js

Lai sāktu darbu, instalējiet Nest.js komandrindas rīku:

npm i -g @nestjs/cli

Pēc tam izveidojiet jaunu projektu, izpildot:

ligzda jauna crud-app

CLI rīks liks jums izvēlēties pakotņu pārvaldnieku, izvēlēties opciju, kas jums šķiet vispiemērotākā. Mēs izmantosim npm, mezgla pakotņu pārvaldnieks.

CLI izveidos pamata Nest.js projektu ar visiem nepieciešamajiem konfigurācijas failiem un sākotnējām atkarībām, kas nepieciešamas lietojumprogrammas palaišanai.

Visbeidzot, dodieties uz projekta direktoriju un palaidiet izstrādes serveri.

cd crud-app
npm palaišanas sākums

Jūs varat atrast šī projekta kodu tajā GitHub krātuve.

Izveidojiet PostgreSQL datu bāzi

Šajā apmācībā tiek izmantota mākoņa PostgreSQL instance, taču tā vietā varat iestatīt vietējo PostgreSQL datu bāzi. Jūs varat instalējiet PostgreSQL operētājsistēmā Windows, operētājsistēmā macOS, vai operētājsistēmā Linux.

Lai iestatītu mākoņa PostgreSQL gadījumu:

1. Dodieties uz ElephantSQL, reģistrējieties un piesakieties sava konta pārskata lapā.
2. Noklikšķiniet uz Izveidojiet jaunu instanci pogu lapas augšējā kreisajā sadaļā, lai izveidotu jaunu gadījumu savai lietojumprogrammai.
3. Ievadiet savas instances nosaukumu, izvēlieties bezmaksas plānu un visbeidzot atlasiet reģionu, lai pabeigtu iestatīšanas procesu.
4. Pēc datu bāzes instances izveides dodieties uz iestatījumi lapu un nokopējiet sniegto datu bāzes URL.

Konfigurējiet datu bāzes savienojumu

Sava projekta saknes direktorijā izveidojiet a .env failu un ielīmējiet datu bāzes savienojuma URL šādi:

DATABASE_URL=""

Tagad instalējiet šīs pakotnes:

npm instalējiet pg typeorm @nestjs/typeorm @nestjs/config

Pēc tam turpiniet un izveidojiet datu bāzes moduli, izmantojot CLI rīku.

nest g moduļu datu bāze

Atveriet datubāze/database.module.ts failu un pievienojiet šādu datu bāzes konfigurācijas kodu:

imports { Modulis } no"@nestjs/common";
imports { ConfigModule, ConfigService } no"@nestjs/config";
imports { TypeOrmModule } no'@nestjs/typeorm';
imports {Lietotājs} no"../users/models/user.entity"; 
@Modulis({
 imports: [
 TypeOrmModule.forRootAsync({
 imports: [ConfigModule], 
 inject: [ConfigService],
 useFactory: asinhronā (configService: ConfigService) => ({
veids: 'postgres',
 url: configService.get('DATABASE_URL'), 
 entītijas: [Lietotājs],
 sinhronizēt: taisnība
 }),
 }),
 ],
})
eksportētklasē Datu bāzes modulis {}

Šis datu bāzes modulis apstrādā savienojumu, konfigurējot TypeORM moduli ar nepieciešamo savienojuma parametru, datu bāzes URL.

Turklāt tas definē lietotāja entītiju kā daļu no konfigurācijas, kas nosaka PostgreSQL datu bāzes tabulā saglabāto datu struktūru un rekvizītus.

Šajā posmā jūsu kods, iespējams, radīs kļūdu, jo jūs vēl neesat izveidojis lietotāju entītiju. To darīsit tālāk norādītajās darbībās.

Atjauniniet failu app.module.ts

Visbeidzot, atjauniniet galveno lietojumprogrammas moduli, lai iekļautu datu bāzes moduļa konfigurāciju.

imports { Modulis } no"@nestjs/common";
imports { ConfigModule } no"@nestjs/config";
imports { AppController } no'./app.controller';
imports { AppService } no'./app.service';
imports { DatabaseModule } no'./database/database.module';
@Modulis({
 imports: [
 ConfigModule.forRoot({
 envFilePath: ".env", 
 }),
 Datu bāzes modulis,
 ],
 kontrolieri: [AppController],
 pakalpojumu sniedzēji: [AppService],
})
eksportētklasē AppModule {}

Definējiet lietotāju moduli

Lietotāju modulis kalpo kā centralizēts komponents, kas ir atbildīgs par API CRUD funkcionalitātes ieviešanai nepieciešamās loģikas iekapsulēšanu un pārvaldību.

Palaidiet šo termināļa komandu, lai izveidotu API lietotāju moduli.

nest g moduļa lietotāji

CLI rīks automātiski atjaunina app.module.ts failu, lai atspoguļotu veiktās izmaiņas, papildus lietotāja moduļa izveidei. Tas nodrošina, ka jaunizveidotais modulis, lietotāji, ir pareizi integrēts lietojumprogrammas moduļa konfigurācijā.

Izveidojiet lietotāja entītiju

TypeORM ir objektu relāciju kartēšanas (ORM) bibliotēka, kas vienkāršo datu bāzes mijiedarbību lietojumprogrammās, kas izmanto TypeScript, kartējot JavaScript objektus datu bāzes tabulās.

Izveidojot lietotāja entītiju, izmantojot TypeORM, jūs definējat lietotāja datu struktūru un rekvizītus PostgreSQL datu bāzē.

Lietotāju direktorijā izveidojiet jaunu modeļi/user.entity.ts un pievienojiet šādu kodu.

imports { Entity, PrimaryGeneratedColumn, Column, } no"veidlapa";
@Entity()
eksportētklasē Lietotājs {
@PrimaryGeneratedColumn()
 id: numuru;
@Kolonna()
 nosaukums: stīga;
@Kolonna()
 e-pasts: stīga;
}

The Lietotājs entītija definē datu bāzē saglabāto lietotāja datu struktūru. Šajā gadījumā tas ir id kā primārās atslēgas kolonnu, un nosaukums un e-pasts kolonnas un to atbilstošās īpašības.

Izveidojiet CRUD API pakalpojumu

Tagad izveidojiet API pakalpojumu, kas pārvaldīs CRUD darbību loģiku, izpildot tālāk norādīto komandu:

nest g pakalpojuma lietotāji

Atveriet user-auth.service.ts failu un pievienojiet šo kodu:

imports {Injicējams} no"@nestjs/common";
imports { InjectRepository } no'@nestjs/typeorm';
imports { Repozitorijs } no'typeform';
imports {Lietotājs} no'./models/user.entity';
@Injicējams()
eksportētklasē UsersService {
konstruktors(
@InjectRepository(Lietotājs)
Privāts userRepository: Repozitorijs,
 ) {}
asinhronā atrast visu (): Apsolīt {
atgrieztiesšis.userRepository.find();
 }
asinhronā findOne (id: numuru): Apsolīt {
atgrieztiesšis.userRepository.findOne({ kur: { id } });
 }
asinhronā izveidot (lietotājs: daļējs): Apsolīt {
konst jaunlietotājs = šis.userRepository.create (lietotājs);
atgrieztiesšis.userRepository.save (jaunais lietotājs);
 }
asinhronā atjaunināt (id: numuru, lietotājs: Daļēji): Apsolīt {
gaidītšis.userRepository.update (id, lietotājs);
atgrieztiesšis.userRepository.findOne({ kur: { id } });
 }
asinhronādzēst(id: numuru): Apsolīt<nederīgs> {
gaidītšis.userRepository.delete (id);
 }
}

Šī UsersService klase definē dažādas API metodes, kas paredzētas CRUD darbību apstrādei. Šīs metodes ietver visu lietotāju datu izgūšanu, konkrēta lietotāja atrašanu, izmantojot viņa ID numuru, izveidošanu jauns lietotājs, esošā lietotāja atjaunināšana un metode konkrēta lietotāja datu dzēšanai datu bāzē.

Definējiet API kontrolieri

Izveidojiet kontrolieri, kas pārvaldīs API galapunktus ar lietotāju saistītajām darbībām.

nest g kontroliera lietotāji

Pēc tam pievienojiet tālāk norādīto kodu users.controller.ts failu.

imports { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } no"@nestjs/common";
imports { UsersService } no'./users.service';
imports {Lietotājs} no'./models/user.entity';
@Controller('api/lietotāji')
eksportētklasē UsersController {
konstruktors(Privāts readonly usersService: UsersService) {}
@Gūt()
asinhronā atrast visu (): Apsolīt {
atgrieztiesšis.usersService.findAll();
 }
@Post()
@HttpCode(201) 
asinhronā izveidot (@Ķermenis() lietotājs: Lietotājs): Apsolīt {
konst izveidotsLietotājs = gaidītšis.usersService.create (lietotājs);
atgriezties izveidotsLietotājs;
 }
@Put(':id')
asinhronā Atjaunināt (@Param('id') id: numuru, @Ķermenis() lietotājs: Lietotājs): Apsolīt<jebkura> {
gaidītšis.usersService.update (id, lietotājs);
atgriezties {ziņa: "Lietotājs ir veiksmīgi atjaunināts" };
 }
@Dzēst(':id')
asinhronādzēst(@Param('id') id: numuru): Apsolīt<jebkura> {
konst lietotājs = gaidītšis.usersService.findOne (id);
ja (!lietotājs) {
mestjauns NotFoundException('Lietotājs neeksistē!');
 }
gaidītšis.usersService.delete (id);
atgriezties {ziņa: "Lietotājs veiksmīgi izdzēsts" };
 }
}

Kontrolieris pārvalda API galapunktus lietotāja darbībām. Tas apstrādā GET pieprasījumus visu lietotāju izgūšanai, POST pieprasījumus jaunu lietotāju izveidei, PUT pieprasījumus esošo lietotāju atjaunināšanai un DELETE pieprasījumus lietotāju dzēšanai.

Izmantojot UsersService un mijiedarbojoties ar Lietotājs entītija, šis kontrolieris nodrošina pilnīgu API, lai pārvaldītu ar lietotāju saistītas darbības ar datubāzē glabātajiem datiem.

Atjauniniet failu users.module.ts

Visbeidzot, atjauniniet users.module.ts failu, kā parādīts tālāk, lai nodrošinātu, ka esat iekļauts Lietotāja entītija un TypeORM modulis, kas izveido savienojumu ar datu bāzi.

imports { Modulis } no"@nestjs/common";
imports { UsersController } no'./users.controller';
imports { UsersService } no'./users.service';
imports { TypeOrmModule } no'@nestjs/typeorm';
imports {Lietotājs} no'./models/user.entity';
@Modulis({
 imports: [TypeOrmModule.forFeature([User])],
 kontrolieri: [UsersController],
 pakalpojumu sniedzēji: [UsersService]
})
eksportētklasē Lietotāju modulis {}

Visbeidzot, turpiniet un pagrieziet izstrādes serveri, lai pārbaudītu CRUD darbības, izmantojot Postman.

npm palaišanas sākums

Serveris tiks startēts ar portu 3000, un jūs varat nosūtīt API pieprasījumus uz to vietnē http://localhost: 3000/api/lietotāji.

Aizmugursistēmas lietojumprogrammu izveide, izmantojot Nest.js

Neatkarīgi no tā, vai izstrādājat vienkāršu REST API vai sarežģītu tīmekļa lietotni, Nest.js piedāvā visaptverošu funkciju un iespēju kopumu, lai izveidotu uzticamu un stabilu aizmugursistēmu.

Nest.js piedāvā strukturētāku pieeju projektu izstrādei nekā Express.js. Tas nodrošina, ka varat droši veidot, mērogot un uzturēt sarežģītas lietojumprogrammas, pateicoties tās organizētajam un modulārajam dizaina modelim.