Sådan bygger du en Nest.js CRUD REST API ved hjælp af TypeORM og PostgreSQL

Som andre Node.js-frameworks tilbyder Nest.js et omfattende værktøjssæt til at bygge robuste og skalerbare backend-tjenester. Ikke desto mindre er det vigtigt at forstå, hvordan man implementerer oprette, læse, opdatere og slette (CRUD) operationer i Nest.js effektivt – disse er de mest fundamentale operationer i udviklingen af API’er.

Lær, hvordan du bygger en Nest.js CRUD REST API ved hjælp af TypeORM og en PostgreSQL-database.

Indholdsfortegnelse

Kom godt i gang med Nest.js

For at komme i gang skal du installere kommandolinjeværktøjet Nest.js:

 npm i -g @nestjs/cli

Opret derefter et nyt projekt ved at køre:

 nest new crud-app

CLI-værktøjet vil bede dig om at vælge en pakkehåndtering, vælg den mulighed, du finder mest at foretrække. Vi bruger npm, Node-pakkehåndteringen.

CLI’en vil stilladsere et grundlæggende Nest.js-projekt med alle de nødvendige konfigurationsfiler og indledende afhængigheder, der kræves for at køre applikationen.

Til sidst skal du navigere til projektbiblioteket og starte udviklingsserveren.

 cd crud-app
npm run start

Du kan finde dette projekts kode i dens GitHub depot.

Opret en PostgreSQL-database

Denne tutorial bruger en cloud PostgreSQL-instans, men du kan konfigurere en lokal PostgreSQL-database i stedet for. Du kan installere PostgreSQL på Windows, på macOS eller på Linux.

Sådan konfigurerer du en Cloud PostgreSQL-instans:

Gå over til ElephantSQLtilmeld dig og log ind på din kontos oversigtsside.

Klik på knappen Opret ny instans øverst til venstre på siden for at oprette en ny instans til din applikation.

Udfyld navnet på din forekomst, vælg den gratis plan, og vælg til sidst regionen for at fuldføre opsætningsprocessen.

Når du har oprettet databaseforekomsten, skal du gå til indstillingssiden og kopiere den angivne database-URL.

Sådan installeres og administreres udvidelser i Chrome

Konfigurer databaseforbindelsen

I dit projekts rodmappe skal du oprette en .env-fil og indsætte databaseforbindelsens URL som følger:

 DATABASE_URL="<your connection url here>"

Installer nu disse pakker:

 npm install pg typeorm @nestjs/typeorm @nestjs/config

Gå derefter videre og opret et databasemodul ved hjælp af CLI-værktøjet.

 nest g module database

Åbn filen database/database.module.ts, og tilføj følgende databasekonfigurationskode:

 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 {}

Dette databasemodul håndterer forbindelsen ved at konfigurere TypeORM-modulet med den nødvendige forbindelsesparameter, databasens URL.

Derudover definerer den brugerenheden som en del af den konfiguration, der specificerer strukturen og egenskaberne for de data, der er gemt i PostgreSQL-databasetabellen.

På dette stadium vil din kode sandsynligvis give en fejl, fordi du ikke har oprettet brugerenheden endnu. Det gør du i de følgende trin.

Opdater app.module.ts-filen

Til sidst skal du opdatere hovedapplikationsmodulet for at inkludere konfigurationen for databasemodulet.

 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 et brugermodul

Brugermodulet fungerer som en centraliseret komponent, ansvarlig for at indkapsle og administrere den logik, der kræves for at implementere API’ens CRUD-funktionalitet.

Kør denne terminalkommando for at oprette API’ens brugermodul.

 nest g module users

CLI-værktøjet opdaterer automatisk app.module.ts-filen, så den afspejler de foretagne ændringer, udover at oprette brugermodulet. Dette sikrer, at det nyoprettede modul, brugere, er korrekt integreret i applikationens modulkonfiguration.

Sådan opretter du et alias til din iCloud-e-mailadresse

Opret en brugerenhed

TypeORM er et ORM-bibliotek (Object-Relational Mapping), der forenkler databaseinteraktioner i applikationer, der bruger TypeScript ved at kortlægge JavaScript-objekter til databasetabeller.

Ved at oprette en brugerentitet ved hjælp af TypeORM definerer du strukturen og egenskaberne for brugerdataene i PostgreSQL-databasen.

I brugerbiblioteket skal du oprette en ny models/user.entity.ts og tilføje følgende kode.

 import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
    @PrimaryGeneratedColumn()
    id: number;
    @Column()
    name: string;
    @Column()
    email: string;
}

Brugerenheden definerer strukturen af de brugerdata, der er gemt i databasen. I dette tilfælde er det id’et som den primære nøglekolonne og navne- og e-mail-kolonnerne og deres tilsvarende egenskaber.

Opret CRUD API-tjenesten

Opret nu API-tjenesten, der administrerer logikken for CRUD-operationerne ved at køre kommandoen nedenfor:

 nest g service users

Åbn filen user-auth.service.ts og tilføj denne kode:

 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-klasse definerer forskellige API-metoder dedikeret til at håndtere CRUD-operationer. Disse metoder omfatter at hente alle brugeres data, finde en bestemt bruger ved hjælp af deres ID-nummer, oprette en ny bruger, opdatere en eksisterende bruger og en metode til at slette en specifik brugers data i databasen.

Definer en controller til API’en

Opret en controller, der skal administrere API-endepunkterne for de brugerrelaterede operationer.

 nest g controller users

Tilføj derefter koden nedenfor til 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' };
  }
}

Controlleren administrerer API-endepunkter for brugeroperationer. Den håndterer GET-anmodninger om at hente alle brugere, POST-anmodninger om at oprette nye brugere, PUT-anmodninger om at opdatere eksisterende brugere og SLET-anmodninger om at slette brugere.

Sådan holder du lavenergitilstand aktiveret permanent på din iPhone

Ved at bruge UsersService og interagere med brugerenheden giver denne controller en komplet API til styring af brugerrelaterede operationer på de data, der er gemt i databasen.

Opdater users.module.ts-filen

Til sidst skal du opdatere filen users.module.ts som vist nedenfor for at sikre, at du inkorporerer User-entiteten og TypeORM-modulet, som etablerer 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 sidst, gå videre og skru udviklingsserveren op for at teste CRUD-operationerne ved hjælp af Postman.

 npm run start

Serveren starter på port 3000, og du kan sende API-anmodninger til den på http://localhost:3000/api/users.

Opbygning af backend-applikationer med Nest.js

Uanset om du udvikler en simpel REST API eller en kompleks webapp, tilbyder Nest.js et omfattende sæt funktioner og muligheder til at konstruere et pålideligt og robust backend-system.

Nest.js tilbyder en mere struktureret tilgang til projektudvikling end Express.js gør. Dette sikrer, at du trygt kan bygge, skalere og vedligeholde komplekse applikationer takket være dets organiserede og modulære designmønster.