Jak zbudować Nest.js CRUD REST API przy użyciu TypeORM i PostgreSQL

Podobnie jak inne frameworki Node.js, Nest.js zapewnia kompleksowy zestaw narzędzi do budowania solidnych i skalowalnych usług zaplecza. Niemniej jednak ważne jest, aby zrozumieć, jak zaimplementować tworzenie, odczytywanie, aktualizowanie i usuwanie (CRUD) operacje w Nest.js wydajnie — to najbardziej podstawowe operacje w rozwoju API.

Dowiedz się, jak zbudować Nest.js CRUD REST API przy użyciu TypeORM i bazy danych PostgreSQL.

Pierwsze kroki z Nest.js

Aby rozpocząć, zainstaluj narzędzie wiersza poleceń Nest.js:

npm i -g @nestjs/cli

Następnie utwórz nowy projekt, uruchamiając:

zagnieżdż nową aplikację crud

Narzędzie CLI wyświetli monit o wybranie menedżera pakietów, wybierz opcję, która najbardziej Ci odpowiada. użyjemy npm, menedżer pakietów Node.

Interfejs CLI utworzy szkielet podstawowego projektu Nest.js ze wszystkimi wymaganymi plikami konfiguracyjnymi i początkowymi zależnościami wymaganymi do uruchomienia aplikacji.

Na koniec przejdź do katalogu projektu i uruchom serwer deweloperski.

cd crud-aplikacja
start biegu npm

Możesz znaleźć kod tego projektu w jego GitHub magazyn.

Utwórz bazę danych PostgreSQL

Ten samouczek używa instancji PostgreSQL w chmurze, ale zamiast tego możesz skonfigurować lokalną bazę danych PostgreSQL. Możesz zainstaluj PostgreSQL w systemie Windows, na macOSlub w systemie Linux.

Aby skonfigurować instancję PostgreSQL w chmurze:

1. Udaj się do ElephantSQL, zarejestruj się i zaloguj na stronie przeglądu swojego konta.
2. Kliknij Utwórz nową instancję w lewej górnej części strony, aby utworzyć nową instancję dla swojej aplikacji.
3. Wpisz nazwę swojej instancji, wybierz bezpłatny plan, a na koniec wybierz region, aby zakończyć proces instalacji.
4. Po utworzeniu instancji bazy danych przejdź do ustawienia stronę i skopiuj dostarczony URL bazy danych.

Skonfiguruj połączenie z bazą danych

W katalogu głównym projektu utwórz plik .env plik i wklej adres URL połączenia z bazą danych w następujący sposób:

DATABASE_URL=""

Teraz zainstaluj te pakiety:

npm zainstaluj pg typeorm @nestjs/typeorm @nestjs/config

Następnie śmiało utwórz moduł bazy danych za pomocą narzędzia CLI.

baza danych modułów g

Otworzyć baza danych/baza danych.moduł.ts plik i dodaj następujący kod konfiguracyjny bazy danych:

import { Moduł } z'@nestjs/wspólne';
import { ConfigModule, ConfigService } z'@nestjs/config';
import { TypeOrmModule } z'@nestjs/typeform';
import { Użytkownik } z„../użytkownicy/modele/użytkownik.jednostka”; 
@Moduł({
 import: [
 TypeOrmModule.forRootAsync({
 importuje: [ConfigModule], 
 wstrzyknąć: [ConfigService],
 użyjFabryka: asynchroniczny (configService: ConfigService) => ({
typ: 'postgres',
 adres URL: configService.get(„URL_BAZY DANYCH”), 
 podmioty: [Użytkownik],
 synchronizować: PRAWDA
 }),
 }),
 ],
})
eksportklasa Moduł bazy danych {}

Ten moduł bazy danych obsługuje połączenie, konfigurując moduł TypeORM z wymaganym parametrem połączenia, czyli adresem URL bazy danych.

Dodatkowo definiuje encję User w ramach konfiguracji określającej strukturę i właściwości danych przechowywanych w tabeli bazy danych PostgreSQL.

Na tym etapie Twój kod prawdopodobnie zgłosi błąd, ponieważ nie utworzyłeś jeszcze encji użytkowników. Zrobisz to w poniższych krokach.

Zaktualizuj plik app.module.ts

Na koniec zaktualizuj główny moduł aplikacji, aby uwzględnić konfigurację modułu bazy danych.

import { Moduł } z'@nestjs/wspólne';
import { Moduł konfiguracyjny } z'@nestjs/config';
import { Kontroler aplikacji } z„./kontroler aplikacji”;
import { Usługa aplikacji } z„./usługa.aplikacji”;
import {Moduł Bazy Danych} z„./baza danych/baza danych.moduł”;
@Moduł({
 import: [
 ConfigModule.forRoot({
 Ścieżka do pliku env: '.env', 
 }),
 Moduł bazy danych,
 ],
 kontrolery: [Kontroler aplikacji],
 dostawcy: [AppService],
})
eksportklasa Moduł aplikacji {}

Zdefiniuj moduł użytkowników

Moduł użytkowników służy jako scentralizowany komponent, odpowiedzialny za enkapsulację i zarządzanie logiką wymaganą do implementacji funkcjonalności CRUD API.

Uruchom to polecenie terminala, aby utworzyć moduł użytkowników interfejsu API.

zagnieżdżać użytkowników modułu g

Narzędzie CLI automatycznie aktualizuje plik aplikacja.moduł.ts plik, aby odzwierciedlić wprowadzone zmiany, oprócz tworzenia modułu użytkownika. Daje to pewność, że nowo utworzony moduł, czyli użytkownicy, zostanie odpowiednio zintegrowany z konfiguracją modułu aplikacji.

Utwórz jednostkę użytkownika

TypeORM to biblioteka mapowania obiektowo-relacyjnego (ORM), która upraszcza interakcje z bazą danych w aplikacjach korzystających z języka TypeScript, mapując obiekty JavaScript na tabele bazy danych.

Tworząc encję użytkownika za pomocą TypeORM, definiujesz strukturę i właściwości danych użytkownika w bazie danych PostgreSQL.

W katalogu użytkowników utwórz nowy modele/user.entity.ts i dodaj następujący kod.

import { Element, kolumna podstawowagenerowana, kolumna, } z„formularz typu”;
@Podmiot()
eksportklasa Użytkownik {
@PrimaryGeneratedColumn()
 ID: numer;
@Kolumna()
 nazwa: strunowy;
@Kolumna()
 e-mail: strunowy;
}

The Użytkownik podmiot definiuje strukturę danych użytkownika przechowywanych w bazie danych. W tym przypadku to jest ID jako kolumna klucza podstawowego i nazwa I e-mail kolumny i odpowiadające im właściwości.

Utwórz usługę CRUD API

Teraz utwórz usługę API, która będzie zarządzać logiką operacji CRUD, uruchamiając poniższe polecenie:

użytkownicy usługi nest g

Otworzyć user-auth.service.ts plik i dodaj ten kod:

import { Do wstrzykiwań } z'@nestjs/wspólne';
import { InjectRepository } z'@nestjs/typeform';
import { Repozytorium } z„typ”;
import {Użytkownik} z„./modele/użytkownik.jednostka”;
@Do wstrzykiwań()
eksportklasa UserService {
konstruktor(
@InjectRepository(Użytkownik)
prywatny userRepository: Repozytorium,
 ) {}
asynchroniczny Znajdź wszystko(): Obietnica {
powrótTen.userRepository.find();
 }
asynchroniczny znajdźJeden (identyfikator: numer): Obietnica {
powrótTen.userRepository.findOne({ gdzie: { id } });
 }
asynchroniczny utwórz (użytkownik: Częściowy): Obietnica {
konst nowy użytkownik = Ten.userRepository.create (użytkownik);
powrótTen.userRepository.save (nowy użytkownik);
 }
asynchroniczny aktualizacja (identyfikator: numer, użytkownik: Częściowe): Obietnica {
czekać naTen.userRepository.update (identyfikator, użytkownik);
powrótTen.userRepository.findOne({ gdzie: { id } });
 }
asynchronicznyusuwać(ID: numer): Obietnica<próżnia> {
czekać naTen.userRepository.delete (identyfikator);
 }
}

Ta klasa UsersService definiuje różne metody API dedykowane do obsługi operacji CRUD. Metody te obejmują pobieranie danych wszystkich użytkowników, wyszukiwanie konkretnego użytkownika na podstawie jego numeru identyfikacyjnego, tworzenie nowego użytkownika, aktualizację istniejącego użytkownika oraz sposób usunięcia danych konkretnego użytkownika z bazy danych.

Zdefiniuj kontroler dla interfejsu API

Utwórz kontroler, który będzie zarządzał punktami końcowymi interfejsu API dla operacji związanych z użytkownikami.

Użytkownicy kontrolera gniazda g

Następnie dodaj poniższy kod do pliku użytkownicy.kontroler.ts plik.

import { Kontroler, Get, Post, Body, Put, Param, Delete, NotFoundException, HttpCode } z'@nestjs/wspólne';
import {Usługa użytkowników} z„./usługa.użytkowników”;
import { Użytkownik } z„./modele/użytkownik.jednostka”;
@Kontroler(„interfejs API/użytkownicy”)
eksportklasa Kontroler użytkowników {
konstruktor(prywatny Tylko do odczytuUsługa użytkowników: Usługa użytkowników) {}
@Dostawać()
asynchroniczny Znajdź wszystko(): Obietnica {
powrótTen.usersService.findAll();
 }
@Post()
@HttpCode(201) 
asynchroniczny tworzyć(@Ciało() użytkownik: Użytkownik): Obietnica {
konst utworzony użytkownik = czekać naTen.usersService.create (użytkownik);
powrót utworzony użytkownik;
 }
@Umieścić(':ID')
asynchroniczny aktualizacja (@Param('ID') ID: numer, @Ciało() użytkownik: Użytkownik): Obietnica<każdy> {
czekać naTen.usersService.update (identyfikator, użytkownik);
powrót { wiadomość: „Użytkownik został pomyślnie zaktualizowany” };
 }
@Usuwać(':ID')
asynchronicznyusuwać(@Param('ID') ID: numer): Obietnica<każdy> {
konst użytkownik = czekać naTen.usersService.findOne (identyfikator);
Jeśli (!użytkownik) {
rzucićnowy Nieznaleziony wyjątek('Użytkownik nie istnieje!');
 }
czekać naTen.usersService.delete (identyfikator);
powrót { wiadomość: „Użytkownik został pomyślnie usunięty” };
 }
}

Kontroler zarządza punktami końcowymi API dla operacji użytkownika. Obsługuje żądania GET w celu odzyskania wszystkich użytkowników, żądania POST w celu utworzenia nowych użytkowników, żądania PUT w celu zaktualizowania istniejących użytkowników oraz żądania DELETE w celu usunięcia użytkowników.

Korzystając z UżytkownicyUsługa i interakcji z Użytkownik jednostka, ten kontroler zapewnia kompletne API do zarządzania operacjami użytkownika na danych przechowywanych w bazie danych.

Zaktualizuj plik users.module.ts

Na koniec zaktualizuj plik użytkownicy.moduł.ts plik, jak pokazano poniżej, aby upewnić się, że dołączono plik Jednostka użytkownika oraz moduł TypeORM, który nawiązuje połączenie z bazą danych.

import { Moduł } z'@nestjs/wspólne';
import { Kontroler użytkowników } z„./użytkownicy.kontroler”;
import {Usługa użytkowników} z„./usługa.użytkowników”;
import { TypeOrmModule } z'@nestjs/typeform';
import { Użytkownik } z„./modele/użytkownik.jednostka”;
@Moduł({
 importuje: [TypeOrmModule.forFeature([Użytkownik])],
 kontrolery: [UsersController],
 dostawcy: [UsersService]
})
eksportklasa Moduł użytkowników {}

Na koniec śmiało uruchom serwer programistyczny, aby przetestować operacje CRUD za pomocą Postmana.

start biegu npm

Serwer uruchomi się na porcie 3000 i możesz wysyłać do niego żądania API pod adresem http://localhost: 3000/api/użytkowników.

Tworzenie aplikacji backendowych za pomocą Nest.js

Niezależnie od tego, czy tworzysz prosty interfejs API REST, czy złożoną aplikację internetową, Nest.js oferuje kompleksowy zestaw funkcji i możliwości do budowy niezawodnego i niezawodnego systemu zaplecza.

Nest.js oferuje bardziej ustrukturyzowane podejście do tworzenia projektów niż Express.js. Zapewnia to pewność budowania, skalowania i utrzymywania złożonych aplikacji dzięki zorganizowanemu i modułowemu wzorowi projektowemu.