Stejně jako ostatní frameworky Node.js poskytuje Nest.js komplexní sadu nástrojů pro vytváření robustních a škálovatelných backendových služeb. Nicméně je důležité pochopit, jak efektivně implementovat operace vytvoření, čtení, aktualizace a mazání (CRUD) v Nest.js – to jsou nejzákladnější operace při vývoji API.
Přečtěte si, jak vytvořit Nest.js CRUD REST API pomocí TypeORM a databáze PostgreSQL.
Table of Contents
Začínáme s Nest.js
Chcete-li začít, nainstalujte nástroj příkazového řádku Nest.js:
npm i -g @nestjs/cli
Dále vytvořte nový projekt spuštěním:
nest new crud-app
Nástroj CLI vás vyzve, abyste si vybrali správce balíčků, vyberte možnost, která vám nejvíce vyhovuje. Použijeme npm, správce balíčků Node.
CLI vytvoří základní projekt Nest.js se všemi požadovanými konfiguračními soubory a počátečními závislostmi potřebnými ke spuštění aplikace.
Nakonec přejděte do adresáře projektu a spusťte vývojový server.
cd crud-app
npm run start
Kód tohoto projektu najdete v něm GitHub úložiště.
Vytvořte databázi PostgreSQL
Tento výukový program používá cloudovou instanci PostgreSQL, ale místo toho můžete nastavit místní databázi PostgreSQL. PostgreSQL můžete nainstalovat na Windows, na macOS nebo na Linux.
Postup nastavení cloudové instance PostgreSQL:
Nakonfigurujte připojení k databázi
V kořenovém adresáři projektu vytvořte soubor .env a vložte adresu URL připojení k databázi následovně:
DATABASE_URL="<your connection url here>"
Nyní nainstalujte tyto balíčky:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Dále pokračujte a vytvořte databázový modul pomocí nástroje CLI.
nest g module database
Otevřete soubor database/database.module.ts a přidejte následující konfigurační kód databáze:
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 {}
Tento databázový modul zpracovává připojení konfigurací modulu TypeORM s požadovaným parametrem připojení, URL databáze.
Navíc definuje entitu User jako součást konfigurace, která specifikuje strukturu a vlastnosti dat uložených v tabulce databáze PostgreSQL.
V této fázi váš kód pravděpodobně vyvolá chybu, protože jste ještě nevytvořili entitu uživatele. Uděláte to v následujících krocích.
Aktualizujte soubor app.module.ts
Nakonec aktualizujte hlavní aplikační modul tak, aby zahrnoval konfiguraci databázového modulu.
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 {}
Definujte uživatelský modul
Uživatelský modul slouží jako centralizovaná komponenta, která je zodpovědná za zapouzdření a správu logiky potřebné k implementaci funkce CRUD API.
Spuštěním tohoto příkazu terminálu vytvořte uživatelský modul rozhraní API.
nest g module users
Nástroj CLI kromě vytvoření uživatelského modulu automaticky aktualizuje soubor app.module.ts, aby odrážel provedené změny. To zajišťuje, že nově vytvořený modul, uživatelé, je správně integrován do konfigurace modulu aplikace.
Vytvořte entitu uživatele
TypeORM je knihovna Object-Relational Mapping (ORM), která zjednodušuje databázové interakce v aplikacích používajících TypeScript mapováním objektů JavaScriptu na databázové tabulky.
Vytvořením entity User pomocí TypeORM definujete strukturu a vlastnosti uživatelských dat v databázi PostgreSQL.
V adresáři users vytvořte nový models/user.entity.ts a přidejte následující kód.
import { Entity, PrimaryGeneratedColumn, Column, } from "typeorm";@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column()
name: string;
@Column()
email: string;
}
Entita Uživatel definuje strukturu uživatelských dat uložených v databázi. V tomto případě je to id jako sloupec primárního klíče a sloupce název a e-mail a jejich odpovídající vlastnosti.
Vytvořte službu CRUD API
Nyní vytvořte službu API, která bude spravovat logiku operací CRUD spuštěním příkazu níže:
nest g service users
Otevřete soubor user-auth.service.ts a přidejte tento kód:
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);
}
}
Tato třída UsersService definuje různé metody API vyhrazené pro zpracování operací CRUD. Tyto metody zahrnují načtení dat všech uživatelů, vyhledání konkrétního uživatele pomocí jeho ID čísla, vytvoření nového uživatele, aktualizaci stávajícího uživatele a metodu pro smazání dat konkrétního uživatele z databáze.
Definujte řadič pro API
Vytvořte řadič, který bude spravovat koncové body API pro operace související s uživatelem.
nest g controller users
Dále přidejte níže uvedený kód do souboru 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' };
}
}
Řadič spravuje koncové body API pro uživatelské operace. Zpracovává požadavky GET na načtení všech uživatelů, požadavky POST na vytvoření nových uživatelů, požadavky PUT na aktualizaci stávajících uživatelů a požadavky DELETE na smazání uživatelů.
Využitím UsersService a interakcí s entitou User poskytuje tento kontrolér kompletní API pro správu uživatelských operací s daty uloženými v databázi.
Aktualizujte soubor users.module.ts
Nakonec aktualizujte soubor users.module.ts, jak je uvedeno níže, abyste zajistili, že začleníte entitu User a modul TypeORM, který vytvoří připojení k databázi.
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 {}
Nakonec pokračujte a roztočte vývojový server, abyste otestovali operace CRUD pomocí Postmana.
npm run start
Server se spustí na portu 3000 a můžete na něj posílat požadavky API na http://localhost:3000/api/users.
Vytváření backendových aplikací pomocí Nest.js
Ať už vyvíjíte jednoduché REST API nebo složitou webovou aplikaci, Nest.js nabízí komplexní sadu funkcí a schopností pro vytvoření spolehlivého a robustního backendového systému.
Nest.js nabízí strukturovanější přístup k vývoji projektů než Express.js. To zajišťuje, že můžete s jistotou vytvářet, škálovat a udržovat složité aplikace díky svému organizovanému a modulárnímu vzoru návrhu.