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 kan implementere 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.
Innholdsfortegnelse
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 run 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 installere PostgreSQL på Windows, på macOS eller på Linux.
For å sette opp en sky PostgreSQL-forekomst:
Konfigurer databasetilkoblingen
Opprett en .env-fil i prosjektets rotkatalog og lim inn URL-adressen til databasetilkoblingen som følger:
DATABASE_URL="<your connection url here>"
Installer nå disse pakkene:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Deretter går du videre og oppretter en databasemodul ved å bruke CLI-verktøyet.
nest g module database
Åpne database/database.module.ts-filen og legg til følgende databasekonfigurasjonskode:
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 {}
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 { 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 {}
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 module users
CLI-verktøyet oppdaterer automatisk app.module.ts-filen for å gjenspeile endringene som er gjort, i tillegg til å opprette 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.
I brukerkatalogen oppretter du en ny models/user.entity.ts og legger til følgende kode.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
Brukerenheten definerer strukturen til brukerdataene som er lagret i databasen. I dette tilfellet er det ID-en som primærnøkkelkolonnen, og navn- og e-postkolonnene 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 service users
Åpne user-auth.service.ts-filen og legg til denne koden:
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);
}
}
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, oppdatere 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.
nest g controller users
Deretter legger du til koden nedenfor i users.controller.ts-filen.
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' };
}
}
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 brukerenheten, gir denne kontrolleren et komplett API for å administrere brukerrelaterte operasjoner på dataene som er lagret i databasen.
Oppdater users.module.ts-filen
Til slutt oppdaterer du users.module.ts-filen som vist nedenfor for å sikre at du inkorporerer brukerenheten og TypeORM-modulen, som oppretter forbindelsen til databasen.
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 {}
Til slutt, fortsett og snurr opp utviklingsserveren for å teste CRUD-operasjonene med Postman.
npm run start
Serveren starter på port 3000, og du kan sende API-forespørsler til den på http://localhost:3000/api/users.
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.