Hvordan bygge en Nest.js CRUD REST API ved å bruke TypeORM og PostgreSQL

Som andre Node.js-rammeverk tilbyr Nest.js et omfattende verktøysett for å bygge robuste og skalerbare backend-tjenester. Ikke desto mindre er det viktig å forstå hvordan du implementerer opprette, lese, oppdatere og slette (CRUD) operasjoner i Nest.js effektivt – dette er de mest grunnleggende operasjonene i utviklingen av APIer.

Lær hvordan du bygger en Nest.js CRUD REST API ved hjelp av TypeORM og en PostgreSQL-database.

Komme i gang med Nest.js

For å komme i gang, installer kommandolinjeverktøyet Nest.js:

npm i -g @nestjs/cli

Deretter oppretter du et nytt prosjekt ved å kjøre:

nest new crud-app

CLI-verktøyet vil be deg om å velge en pakkebehandling, velg det alternativet du finner mest å foretrekke. Vi bruker npm, Node-pakkebehandleren.

CLI vil stillas et grunnleggende Nest.js-prosjekt med alle nødvendige konfigurasjonsfiler og innledende avhengigheter som kreves for å kjøre applikasjonen.

Til slutt, naviger til prosjektkatalogen og start utviklingsserveren.

cd crud-app
npm kjøre start

Du kan finne dette prosjektets kode i sin GitHub oppbevaringssted.

Opprett en PostgreSQL-database

Denne opplæringen bruker en Cloud PostgreSQL-forekomst, men du kan sette opp en lokal PostgreSQL-database i stedet. Du kan installer PostgreSQL på Windows, på macOS, eller på Linux.

For å sette opp en sky PostgreSQL-forekomst:

1. Gå over til ElephantSQL, registrer deg og logg på kontooversiktssiden.
2. Klikk på Opprett ny forekomst knappen øverst til venstre på siden for å opprette en ny forekomst for applikasjonen din.
3. Fyll inn navnet på forekomsten din, velg gratisplanen, og velg til slutt regionen for å fullføre oppsettsprosessen.
4. Etter å ha opprettet databaseforekomsten, gå til innstillinger side, og kopier den oppgitte database URL.

Konfigurer databasetilkoblingen

I prosjektets rotkatalog oppretter du en .env fil og lim inn URL-adressen til databasetilkoblingen som følger:

DATABASE_URL=""

Installer nå disse pakkene:

npm installer pg typeorm @nestjs/typeorm @nestjs/config

Deretter går du videre og oppretter en databasemodul ved å bruke CLI-verktøyet.

nest g-moduldatabase

Åpne database/database.modul.ts fil og legg til følgende databasekonfigurasjonskode:

import { Modul } fra'@nestjs/common';
import { ConfigModule, ConfigService } fra'@nestjs/config';
import { TypeOrmModule } fra'@nestjs/typeorm';
import { Bruker } fra'../users/models/user.entity'; 
@Modul({
 importerer: [
 TypeOrmModule.forRootAsync({
 importerer: [ConfigModule], 
 inject: [ConfigService],
 useFactory: asynkron (configService: ConfigService) => ({
type: 'postgres',
 url: configService.get('DATABASE_URL'), 
 enheter: [Bruker],
 synkronisere: ekte
 }),
 }),
 ],
})
eksportklasse Databasemodul {}

Denne databasemodulen håndterer tilkoblingen ved å konfigurere TypeORM-modulen med den nødvendige tilkoblingsparameteren, databasens URL.

I tillegg definerer den brukerenheten som en del av konfigurasjonen som spesifiserer strukturen og egenskapene til dataene som er lagret i PostgreSQL-databasetabellen.

På dette stadiet vil koden sannsynligvis gi en feil fordi du ikke har opprettet brukerenheten ennå. Du vil gjøre det i de følgende trinnene.

Oppdater app.module.ts-filen

Til slutt oppdaterer du hovedapplikasjonsmodulen for å inkludere konfigurasjonen for databasemodulen.

import { Modul } fra'@nestjs/common';
import { ConfigModule } fra'@nestjs/config';
import { AppController } fra'./app.controller';
import { AppService } fra'./app.service';
import { DatabaseModule } fra'./database/database.modul';
@Modul({
 importerer: [
 ConfigModule.forRoot({
 envFilePath: '.env', 
 }),
 Databasemodul,
 ],
 kontrollere: [AppController],
 leverandører: [AppService],
})
eksportklasse AppModule {}

Definer en brukermodul

Brukermodulen fungerer som en sentralisert komponent, ansvarlig for å innkapsle og administrere logikken som kreves for å implementere APIens CRUD-funksjonalitet.

Kjør denne terminalkommandoen for å lage API-ens brukermodul.

nest g-modulbrukere

CLI-verktøyet oppdaterer automatisk app.modul.ts fil for å gjenspeile endringene som er gjort, i tillegg til å lage brukermodulen. Dette sikrer at den nyopprettede modulen, brukere, er riktig integrert i applikasjonens modulkonfigurasjon.

Opprett en brukerenhet

TypeORM er et Object-Relational Mapping (ORM)-bibliotek som forenkler databaseinteraksjoner i applikasjoner som bruker TypeScript ved å tilordne JavaScript-objekter til databasetabeller.

Ved å opprette en brukerenhet ved hjelp av TypeORM, definerer du strukturen og egenskapene til brukerdataene i PostgreSQL-databasen.

Opprett en ny i brukerkatalogen modeller/bruker.enhet.ts og legg til følgende kode.

import { Entity, PrimaryGeneratedColumn, Column, } fra"typeorm";
@Entitet()
eksportklasse Bruker {
@PrimaryGeneratedColumn()
 id: Antall;
@Kolonne()
 Navn: streng;
@Kolonne()
 e-post: streng;
}

De Bruker entitet definerer strukturen til brukerdataene som er lagret i databasen. I dette tilfellet er det id som primærnøkkelkolonnen, og Navn og e-post kolonner og deres tilsvarende egenskaper.

Opprett CRUD API-tjenesten

Opprett nå API-tjenesten som vil administrere logikken for CRUD-operasjonene ved å kjøre kommandoen nedenfor:

nest g-tjenestebrukere

Åpne user-auth.service.ts fil og legg til denne koden:

import { Injiserbar } fra'@nestjs/common';
import { InjectRepository } fra'@nestjs/typeorm';
import { Oppbevaringssted } fra'typeorm';
import {Bruker} fra'./models/user.entity';
@Injiserbar()
eksportklasse UsersService {
konstruktør(
@InjectRepository(Bruker)
privat userRepository: Repository,
 ) {}
asynkron finnAlle(): Love {
komme tilbakedette.userRepository.find();
 }
asynkron findOne (id: Antall): Love {
komme tilbakedette.userRepository.findOne({ hvor: { id } });
 }
asynkron opprette (bruker: Delvis): Love {
konst ny bruker = dette.userRepository.create (bruker);
komme tilbakedette.userRepository.save (nybruker);
 }
asynkron oppdatering (id: Antall, bruker: Delvis): Love {
avventedette.userRepository.update (id, bruker);
komme tilbakedette.userRepository.findOne({ hvor: { id } });
 }
asynkronslette(id: Antall): Love<tomrom> {
avventedette.userRepository.delete (id);
 }
}

Denne UsersService-klassen definerer ulike API-metoder dedikert til å håndtere CRUD-operasjoner. Disse metodene inkluderer å hente alle brukernes data, finne en spesifikk bruker ved å bruke deres ID-nummer, opprette en ny bruker, oppdatering av en eksisterende bruker, og en metode for å slette en spesifikk brukers data i databasen.

Definer en kontroller for API

Opprett en kontroller som skal administrere API-endepunktene for brukerrelaterte operasjoner.

brukere av nest g-kontroller

Deretter legger du til koden nedenfor i brukerkontroller.ts fil.

import { Controller, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } fra'@nestjs/common';
import { UsersService } fra'./users.service';
import { Bruker } fra'./models/user.entity';
@Kontroller('api/brukere')
eksportklasse UsersController {
konstruktør(privat readonly usersService: UsersService) {}
@Få()
asynkron finnAlle(): Love {
komme tilbakedette.usersService.findAll();
 }
@Post()
@HttpCode(201) 
asynkron skape(@Kropp() bruker: Bruker): Love {
konst opprettet bruker = avventedette.usersService.create (bruker);
komme tilbake opprettet bruker;
 }
@Sette(':id')
asynkron Oppdater (@Param('id') id: Antall, @Kropp() bruker: Bruker): Love<noen> {
avventedette.usersService.update (id, bruker);
komme tilbake { beskjed: "Bruker oppdatert" };
 }
@Slett(':id')
asynkronslette(@Param('id') id: Antall): Love<noen> {
konst bruker = avventedette.usersService.findOne (id);
hvis (!bruker) {
kasteny NotFoundException('Bruker finnes ikke!');
 }
avventedette.usersService.delete (id);
komme tilbake { beskjed: "Bruker slettet" };
 }
}

Kontrolleren administrerer API-endepunkter for brukeroperasjoner. Den håndterer GET-forespørsler om å hente alle brukere, POST-forespørsler om å opprette nye brukere, PUT-forespørsler om å oppdatere eksisterende brukere og SLETT-forespørsler om å slette brukere.

Ved å bruke UsersService og samhandle med Bruker enhet, gir denne kontrolleren et komplett API for å administrere brukerrelaterte operasjoner på dataene som er lagret i databasen.

Oppdater users.module.ts-filen

Til slutt, oppdater brukere.modul.ts fil som vist nedenfor for å sikre at du inkorporerer Brukerenhet og TypeORM-modulen, som etablerer forbindelsen til databasen.

import { Modul } fra'@nestjs/common';
import { UsersController } fra'./users.controller';
import { UsersService } fra'./users.service';
import { TypeOrmModule } fra'@nestjs/typeorm';
import { Bruker } fra'./models/user.entity';
@Modul({
 importerer: [TypeOrmModule.forFeature([User])],
 kontrollere: [UsersController],
 leverandører: [UsersService]
})
eksportklasse UsersModule {}

Til slutt, fortsett og snurr opp utviklingsserveren for å teste CRUD-operasjonene med Postman.

npm kjøre start

Serveren starter på port 3000, og du kan sende API-forespørsler til den på http://localhost: 3000/api/brukere.

Bygge backend-applikasjoner med Nest.js

Enten du utvikler en enkel REST API eller en kompleks nettapp, tilbyr Nest.js et omfattende sett med funksjoner og muligheter for å konstruere et pålitelig og robust backend-system.

Nest.js tilbyr en mer strukturert tilnærming til prosjektutvikling enn Express.js gjør. Dette sikrer at du trygt kan bygge, skalere og vedlikeholde komplekse applikasjoner, takket være det organiserte og modulære designmønsteret.