Precis som andra Node.js-ramverk tillhandahåller Nest.js en omfattande verktygslåda för att bygga robusta och skalbara backend-tjänster. Icke desto mindre är det viktigt att förstå hur man implementerar skapa, läs, uppdatera och ta bort (CRUD) operationer i Nest.js effektivt—detta är de mest grundläggande operationerna i utvecklingen av API:er.
Lär dig hur du bygger ett Nest.js CRUD REST API med TypeORM och en PostgreSQL-databas.
Innehållsförteckning
Komma igång med Nest.js
För att komma igång installerar du kommandoradsverktyget Nest.js:
npm i -g @nestjs/cli
Skapa sedan ett nytt projekt genom att köra:
nest new crud-app
CLI-verktyget kommer att uppmana dig att välja en pakethanterare, välj det alternativ som du tycker är mest att föredra. Vi kommer att använda npm, Node-pakethanteraren.
CLI kommer att bygga ett grundläggande Nest.js-projekt med alla nödvändiga konfigurationsfiler och initiala beroenden som krävs för att köra applikationen.
Slutligen, navigera till projektkatalogen och starta utvecklingsservern.
cd crud-app
npm run start
Du kan hitta detta projekts kod i dess GitHub förvaret.
Skapa en PostgreSQL-databas
Den här handledningen använder en PostgreSQL-molninstans, men du kan ställa in en lokal PostgreSQL-databas istället. Du kan installera PostgreSQL på Windows, på macOS eller på Linux.
Så här ställer du in en PostgreSQL-molninstans:
Konfigurera databasanslutningen
Skapa en .env-fil i projektets rotkatalog och klistra in webbadressen för databasanslutningen enligt följande:
DATABASE_URL="<your connection url here>"
Installera nu dessa paket:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Gå sedan vidare och skapa en databasmodul med CLI-verktyget.
nest g module database
Öppna filen database/database.module.ts och lägg till följande databaskonfigurationskod:
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 {}
Denna databasmodul hanterar anslutningen genom att konfigurera TypeORM-modulen med den nödvändiga anslutningsparametern, databasens URL.
Dessutom definierar den User-entiteten som en del av konfigurationen som specificerar strukturen och egenskaperna för data som lagras i PostgreSQL-databastabellen.
I det här skedet kommer din kod förmodligen att ge ett fel eftersom du inte har skapat användarenheten ännu. Du gör det i följande steg.
Uppdatera filen app.module.ts
Uppdatera slutligen huvudapplikationsmodulen så att den inkluderar konfigurationen för databasmodulen.
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 {}
Definiera en användarmodul
Användarmodulen fungerar som en centraliserad komponent, ansvarig för att kapsla in och hantera logiken som krävs för att implementera API:s CRUD-funktionalitet.
Kör detta terminalkommando för att skapa API:ets användarmodul.
nest g module users
CLI-verktyget uppdaterar automatiskt app.module.ts-filen för att återspegla de ändringar som gjorts, förutom att skapa användarmodulen. Detta säkerställer att den nyskapade modulen, användare, är korrekt integrerad i applikationens modulkonfiguration.
Skapa en användarenhet
TypeORM är ett ORM-bibliotek (Object-Relational Mapping) som förenklar databasinteraktioner i applikationer som använder TypeScript genom att mappa JavaScript-objekt till databastabeller.
Genom att skapa en User-entitet med TypeORM definierar du strukturen och egenskaperna för användardata i PostgreSQL-databasen.
Skapa en ny models/user.entity.ts i användarkatalogen och lägg till följande kod.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
Entiteten Användare definierar strukturen för användardata som lagras i databasen. I det här fallet är det id som primärnyckelkolumn, och namn- och e-postkolumner och deras motsvarande egenskaper.
Skapa CRUD API-tjänsten
Skapa nu API-tjänsten som kommer att hantera logiken för CRUD-operationerna genom att köra kommandot nedan:
nest g service users
Öppna filen user-auth.service.ts och lägg till denna kod:
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);
}
}
Denna UsersService-klass definierar olika API-metoder dedikerade till att hantera CRUD-operationer. Dessa metoder inkluderar att hämta alla användares data, hitta en specifik användare med deras ID-nummer, skapa en ny användare, uppdatera en befintlig användare och en metod för att radera en specifik användares data i databasen.
Definiera en styrenhet för API
Skapa en kontroller som kommer att hantera API-slutpunkterna för de användarrelaterade operationerna.
nest g controller users
Lägg sedan till koden nedan 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' };
}
}
Styrenheten hanterar API-slutpunkter för användaroperationer. Den hanterar GET-förfrågningar för att hämta alla användare, POST-förfrågningar för att skapa nya användare, PUT-förfrågningar för att uppdatera befintliga användare och DELETE-förfrågningar för att ta bort användare.
Genom att använda UsersService och interagera med användarenheten tillhandahåller denna kontrollant ett komplett API för att hantera användarrelaterade operationer på data som lagras i databasen.
Uppdatera filen users.module.ts
Uppdatera till sist filen users.module.ts enligt nedan för att säkerställa att du införlivar User-entiteten och TypeORM-modulen, som upprättar anslutningen till 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 {}
Slutligen, fortsätt och snurra upp utvecklingsservern för att testa CRUD-operationerna med Postman.
npm run start
Servern startar på port 3000 och du kan skicka API-förfrågningar till den på http://localhost:3000/api/users.
Bygga backend-applikationer med Nest.js
Oavsett om du utvecklar ett enkelt REST API eller en komplex webbapp, erbjuder Nest.js en omfattande uppsättning funktioner och möjligheter för att konstruera ett pålitligt och robust backend-system.
Nest.js erbjuder ett mer strukturerat tillvägagångssätt för projektutveckling än vad Express.js gör. Detta säkerställer att du med säkerhet kan bygga, skala och underhålla komplexa applikationer, tack vare dess organiserade och modulära designmönster.