Stejně jako mnoho jiných frameworků pro Node.js, i Nest.js nabízí bohatou sadu nástrojů pro vývoj spolehlivých a škálovatelných backendových aplikací. Zásadní je však pochopit, jak efektivně implementovat operace pro vytváření, čtení, úpravy a mazání dat (CRUD), které představují základní kameny při návrhu API.
V tomto článku se dozvíte, jak vytvořit REST API s funkcemi CRUD v Nest.js, využívající TypeORM a databázi PostgreSQL.
Úvod do Nest.js
Pro začátek je nutné nainstalovat nástroj příkazové řádky Nest.js:
npm i -g @nestjs/cli
Následně vytvořte nový projekt použitím příkazu:
nest new crud-app
CLI nástroj vás vyzve k výběru správce balíčků. Zvolte ten, který vám nejvíce vyhovuje. V tomto případě použijeme npm, standardní správce balíčků pro Node.js.
CLI automaticky vygeneruje základní projekt Nest.js se všemi potřebnými konfiguračními soubory a počátečními závislostmi pro běh aplikace.
Nakonec se přesuňte do adresáře projektu a spusťte vývojový server.
cd crud-app
npm run start
Kompletní kód tohoto projektu je k dispozici v GitHub repozitáři.
Zřízení databáze PostgreSQL
Tento návod využívá cloudovou instanci PostgreSQL, nicméně můžete si také nastavit lokální databázi. PostgreSQL lze snadno nainstalovat na systémy Windows, macOS i Linux.
Postup pro nastavení cloudové instance PostgreSQL je následující:
Konfigurace připojení k databázi
V kořenovém adresáři projektu vytvořte soubor s názvem .env a vložte do něj zkopírovanou URL adresu databáze, například takto:
DATABASE_URL="<vaše připojovací URL adresa zde>"
Nyní nainstalujte následující balíčky:
npm install pg typeorm @nestjs/typeorm @nestjs/config
Dále pomocí CLI vytvořte databázový modul:
nest g module database
Otevřete soubor database/database.module.ts a vložte do něj následující konfigurační kód pro databázi:
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 modul databáze zajišťuje konfiguraci připojení pomocí modulu TypeORM, přičemž klíčovým parametrem je URL adresa databáze.
Navíc definuje entitu User, což specifikuje strukturu a vlastnosti dat ukládaných v tabulce PostgreSQL.
V tomto okamžiku může váš kód hlásit chybu, protože entita uživatele ještě nebyla definována. To vyřešíte v následujících krocích.
Aktualizace souboru app.module.ts
Nakonec aktualizujte hlavní modul aplikace 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 {}
Definice modulu pro uživatele
Modul pro uživatele představuje centralizovanou komponentu, která je odpovědná za zapouzdření a správu logiky potřebné pro implementaci funkcí CRUD API.
Pro vytvoření tohoto modulu API použijte následující příkaz v terminálu:
nest g module users
Kromě vytvoření modulu pro uživatele, nástroj CLI také automaticky aktualizuje soubor app.module.ts, aby zohlednil provedené změny. Tím je zajištěno, že nově vytvořený modul je správně integrován do konfigurace aplikace.
Vytvoření entity uživatele
TypeORM je knihovna pro mapování objektů (ORM), která usnadňuje interakci s databází v aplikacích napsaných v TypeScriptu. Děje se to 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ý soubor models/user.entity.ts a vložte do něj 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 User definuje strukturu uživatelských dat uložených v databázi. V tomto případě id jako sloupec primárního klíče a sloupce name (jméno) a email (e-mail) a jejich odpovídající vlastnosti.
Vytvoření služby CRUD API
Nyní vytvořte službu API, která bude spravovat logiku CRUD operací. Použijte k tomu následující příkaz:
nest g service users
Otevřete soubor user-auth.service.ts a vložte do něj 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);
}
}
Třída UsersService definuje různé metody API pro zpracování CRUD operací. Mezi tyto metody patří získávání dat všech uživatelů, vyhledání konkrétního uživatele podle jeho ID, vytvoření nového uživatele, aktualizace existujícího uživatele a metoda pro smazání uživatele z databáze.
Definice kontroleru pro API
Vytvořte kontroler, který bude spravovat koncové body API pro operace související s uživatelem.
nest g controller users
Následně vložte 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' };
}
}
Kontroler spravuje koncové body API pro uživatelské operace. Zpracovává požadavky GET pro načtení všech uživatelů, POST pro vytváření nových uživatelů, PUT pro aktualizaci existujících uživatelů a DELETE pro smazání uživatelů.
S pomocí třídy UsersService a interakcí s entitou User poskytuje tento kontroler 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, aby bylo zajištěno zahrnutí entity User a modulu TypeORM, který zajišťuje 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 {}
Nyní spusťte vývojový server a otestujte CRUD operace pomocí Postmana.
npm run start
Server se spustí na portu 3000 a můžete na něj posílat API požadavky na adrese http://localhost:3000/api/users.
Vývoj backendových aplikací s Nest.js
Ať už vyvíjíte jednoduché REST API nebo složitou webovou aplikaci, Nest.js poskytuje komplexní sadu funkcí a možností 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ž například Express.js. To zajišťuje, že můžete s jistotou vytvářet, škálovat a udržovat složité aplikace díky organizovanému a modulárnímu vzoru návrhu.