I likhet med andre Node.js-rammeverk, tilbyr Nest.js en solid samling verktøy for å utvikle pålitelige og skalerbare backend-tjenester. Det er likevel avgjørende å forstå hvordan man implementerer opprett-, lese-, oppdaterings- og sletteoperasjoner (CRUD) på en effektiv måte i Nest.js – dette utgjør kjernen i API-utvikling.
Denne veiledningen tar for seg hvordan du bygger en Nest.js CRUD REST API ved å bruke TypeORM og en PostgreSQL-database.
Start med Nest.js
For å begynne, installer Nest.js-kommandolinjeverktøyet:
npm i -g @nestjs/cli
Deretter oppretter du et nytt prosjekt ved å kjøre:
nest new crud-app
Verktøyet vil be deg om å velge en pakkebehandler. Velg den du foretrekker. Vi benytter npm, standard pakkebehandler for Node.
CLI vil opprette et grunnleggende Nest.js-prosjekt med alle nødvendige konfigurasjonsfiler og initielle avhengigheter for å kjøre applikasjonen.
Til slutt, naviger til prosjektmappen og start utviklingsserveren.
cd crud-app
npm run start
Du finner prosjektkoden i det tilhørende GitHub-repositoriet.
Opprett en PostgreSQL-database
Denne opplæringen bruker en Cloud PostgreSQL-forekomst, men du kan også bruke en lokal PostgreSQL-database. Du kan installere PostgreSQL på Windows, macOS eller Linux.
For å konfigurere en skybasert PostgreSQL-forekomst:
- Gå til ElephantSQL, registrer deg og logg inn på kontrollpanelet.
- Klikk på «Opprett ny instans» øverst til venstre på siden for å opprette en ny instans for applikasjonen din.
- Fyll inn navnet på instansen din, velg gratisabonnementet, og velg til slutt regionen for å fullføre oppsettprosessen.
- Etter at databaseinstansen er opprettet, gå til innstillingssiden og kopier den angitte database-URLen.
Konfigurer databasetilkoblingen
Opprett en .env-fil i prosjektets rotkatalog og lim inn databaseforbindelses-URLen på følgende måte:
DATABASE_URL="<din tilkoblings-URL her>"
Installer deretter disse pakkene:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Gå videre og opprett en databasemodul ved hjelp av CLI-verktøyet.
nest g module database
Åpne filen database/database.module.ts og legg til følgende kode for databasekonfigurasjon:
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 brukerentiteten som en del av konfigurasjonen, og angir strukturen og egenskapene til dataene som er lagret i PostgreSQL-databasetabellen.
På dette tidspunktet vil koden sannsynligvis vise en feil fordi du ikke har opprettet brukerentiteten ennå. Dette vil du gjøre i de kommende 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 som er ansvarlig for å kapsle inn og administrere logikken som kreves for å implementere APIets CRUD-funksjonalitet.
Kjør denne terminalkommandoen for å lage APIets brukermodul.
nest g module users
CLI-verktøyet oppdaterer app.module.ts-filen automatisk for å gjenspeile de utførte endringene, i tillegg til å opprette brukermodulen. Dette sikrer at den nyopprettede modulen, brukere, er riktig integrert i applikasjonens modulkonfigurasjon.
Opprett en brukerentitet
TypeORM er et bibliotek for objektrelasjonskartlegging (ORM) som forenkler databaseinteraksjoner i applikasjoner som bruker TypeScript ved å knytte JavaScript-objekter til databasetabeller.
Ved å opprette en brukerentitet ved hjelp av TypeORM, definerer du strukturen og egenskapene til brukerdataene i PostgreSQL-databasen.
I brukermappen oppretter du en ny fil 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;
}
Brukerentiteten definerer strukturen til brukerdataene som lagres 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 skal administrere logikken for CRUD-operasjonene, ved å kjøre kommandoen nedenfor:
nest g service users
Åpne filen user-auth.service.ts 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 henting av alle brukeres data, finne en spesifikk bruker ved hjelp av ID-nummeret, 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 filen users.controller.ts.
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 DELETE-forespørsler om å slette brukere.
Ved å bruke UsersService og samhandle med brukerentiteten, 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 inkluderer brukerentiteten 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 fortsetter du og starter 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.
Utvikle backend-applikasjoner med Nest.js
Enten du utvikler en enkel REST API eller en kompleks webapp, tilbyr Nest.js et omfattende sett med funksjoner og muligheter for å bygge et pålitelig og robust backend-system.
Nest.js tilbyr en mer strukturert tilnærming til prosjektutvikling enn Express.js. Dette sikrer at du trygt kan bygge, skalere og vedlikeholde komplekse applikasjoner, takket være det organiserte og modulære designmønsteret.