API CRUD zarządza danymi za pomocą czterech podstawowych operacji na bazie danych: tworzenia, odczytu, aktualizacji i usuwania. Możesz stworzyć proste CRUD API używając tylko Express i bazy danych PostgreSQL.

Zacznij od stworzenia serwera Express, z którym połączysz się z PostgreSQL. Następnie utwórz funkcje CRUD i podłącz je do punktów końcowych API. Gdy to zrobisz, będziesz mógł połączyć Node z PostgreSQL i wykonywać zapytania do bazy danych na każdej trasie.

Wymagania wstępne do zbudowania API

Aby śledzić ten samouczek, powinieneś:

  • Zainstaluj Node na swoim komputerze.
  • Zainstaluj serwer PostgreSQL na swoim komputerze.
  • mieć podstawową wiedzę na temat Express.js.

Utwórz serwer ekspresowy

Do utwórz serwer Express, zacznij od utworzenia nowego katalogu i wpisania go:

Notatki mkdir
płyta CD notatki

Następnie zainicjuj npm:

npm początek -y

To polecenie wygeneruje pakiet.json plik w folderze notatek. Na koniec zainstaluj Express.

npm zainstalować wyrazić

Utwórz nowy plik o nazwie index.js i dodaj następujący kod.

instagram viewer 
stały ekspres = wymagać("wyrazić");
stały aplikacja = ekspres();
aplikacja.posługiwać się(wyrazić.urlencoded({
 rozszerzony: PRAWDA
}));
aplikacja.posługiwać się(wyrazić.json())
app.słuchaj (3000, () => konsola.log("Nasłuch na porcie 3000"));

Spowoduje to utworzenie nowego serwera nasłuchującego na porcie 3000.

Utwórz bazę danych PostgreSQL

Wykonaj następujące polecenie w wierszu poleceń psql, aby utworzyć bazę danych PostgreSQL o nazwie noteb.

postgres=# UTWÓRZ BAZĘ DANYCH zauważyćb;

Uruchom to polecenie, aby wypisz wszystkie bazy danych Postgres i sprawdź, czy utworzyłeś bazę danych noteb:

postgres=# \l

Połącz się z bazą danych

Po pierwsze, po pierwsze, podłącz aplikację Node do serwera PostgreSQL. Możesz użyć modułu node-Postgres.

Uruchom następujące polecenie, aby zainstalować go przez npm:

npm zainstalować pg

Dobrą praktyką jest łączenie się z bazą danych w osobnym pliku.

Utwórz nowy plik o nazwie db.js i dodaj następujące.

stały { Klient } = wymagać("str");
stały { użytkownik, host, baza danych, hasło, port } = wymagać("./dbKonfiguracja");
stały klient = Nowy Klient({
 użytkownik,
 gospodarz,
 Baza danych,
 hasło,
 Port,
});
klient.łączyć();
moduł.eksport = klient;

Tutaj eksportujesz ciąg połączenia, którego będziesz używać do komunikacji z bazą danych. Zauważ, że czytasz ustawienia połączenia z bazą danych z pliku konfiguracyjnego o nazwie dbConfig.js. Dlatego utwórz dbConfig.js i dodaj do niego następujące dane.

moduł.eksport = {
 użytkownik: "{dbUżytkownik}",
 gospodarz: "{dbHost}",
 Baza danych: "zauważyć",
 hasło: "{dbHasło}",
 port: 5432,
};

Pamiętaj, aby zastąpić szczegóły bazy danych własnymi wartościami lokalnymi.

Utwórz tabelę PostgreSQL

W wierszu polecenia psql utwórz tabelę o nazwie notatki. Na początek połącz się z bazą danych noteb za pomocą polecenia \c.

postgres=# \c zanotowaneb

Następnie utwórz tabelę w połączonej bazie danych za pomocą polecenia CREATE TABLE.

zanotowanyb=# CREATE TABLE notatki (
 ID SERYJNY KLUCZ PODSTAWOWY,
 uwaga VARCHAR(255)
);

Ta tabela jest dość prosta. Ma tylko identyfikator, który jest automatycznie generowanym kluczem podstawowym i polem tekstowym o nazwie uwaga.

Utwórz notatkę

Zamiast wykonywać operacje CRUD na trasach, utwórz funkcje, które będą współdziałać z bazą danych w osobnym pliku.

Utwórz plik pomocniczy o nazwie pomocnik.js i zaimportuj obiekt połączenia z db.js.

stały klient = wymagać("./db");

Użyj poniższego kodu, aby utworzyć funkcję createNote().

stały utwórzNotatkę = (wymagane, odp.) => {
próbować {
stały { notatka } = zam.ciało;
jeśli (! uwaga) {
rzucićBłąd(„Wyślij notatkę w treść żądania");
 }
klient.zapytanie(
 "WSTAWIĆW notatki (notatka) WARTOŚCI ($1)",
[Notatka],
 (błąd, dane) => {
res.status(201).json({
 błąd: zero,
 wiadomość: "Utworzono nową notatkę",
 });
 }
 );
 } złapać (błąd) {
res.status(500).json({
błąd: błąd.wiadomość,
 komunikat: „Nie udało się StwórzNowy Notatka",
 });
 }
};

Ta funkcja najpierw sprawdza, czy treść żądania zawiera notatkę. Jeśli notatka jest nieobecna, zgłasza błąd.

Aby utworzyć notatkę, funkcja używa klauzuli INSERT. Zwraca obiekt JSON zawierający pusty komunikat o błędzie i komunikat o powodzeniu, jeśli się powiedzie.

Pobierz wszystkie notatki

Aby pobrać wszystkie notatki z tabeli, użyj klauzuli SELECT *.

stały getNotes = (wymagane, odp.) => {
próbować {
 klient.zapytanie("WYBIERZ * Z notatek", (błąd, dane) => {
jeśli (błądzić) rzucić błądzić;
res.status(200).json({
 błądzić: zero,
notatki: dane.wydziwianie,
 });
 });
 } złapać (błąd) {
res.status(500).json({
błądzić: błąd.wiadomość,
 uwagi: zero,
 });
 }
};

getNotes() wysyła tablicę notatek w obiekcie odpowiedzi, jeśli zapytanie się powiedzie.

Uzyskaj notatkę według identyfikatora

Interfejs API będzie miał również punkt końcowy, który zwraca notatkę według identyfikatora. W helper.js dodaj funkcję getNoteById().

stały getNoteById = (req, res) => {
próbować {
stały { id } = wymagane.params;
 klient.zapytanie("SELECT * Z notatek WHERE id=$1", [id], (błąd, dane) => {
jeśli (błądzić) rzucić błądzić;
res.status(200).json({
 błądzić: zero,
Notatka: dane.wydziwianie[0],
 });
 });
 } złapać (błąd) {
res.status(500).json({
błądzić: błądzić.wiadomość,
 Notatka: zero,
 });
 }
};

Ta funkcja zwróci obiekt JSON zawierający notatkę i obiekt błędu.

Zaktualizuj notatkę według identyfikatora

Aby zaktualizować notatkę, potrzebujesz notatki i identyfikatora tej notatki. Otrzymasz notatkę z treści żądania i identyfikator z adresu URL.

Funkcja updateNoteById() używa klauzuli UPDATE, aby zaktualizować istniejącą notatkę o nową notatkę.

stały updateNoteById = (req, res) => {
próbować {
stały { id } = wymagane.params;
stały { notatka } = zam.ciało;
klient.zapytanie(
 "AKTUALIZACJA notatki USTAWIĆ notatka = $1GDZIEID = $2",
[uwaga, identyfikator],
 (błąd, dane) => {
jeśli (błądzić) rzucić błądzić;
res.status(201).json({
 błądzić: zero,
 wiadomość: "Zaktualizowana uwaga",
 });
 }
 );
 } złapać (błąd) {
res.status(500).json({
błądzić: błąd.wiadomość,
 wiadomość: "Nie udało się zaktualizować notatki",
 });
 }
};

Ta funkcja zwraca komunikat o powodzeniu, jeśli tabela jest aktualizowana, oraz komunikat o błędzie, jeśli tak nie jest.

Usuń notatkę według identyfikatora

Aby usunąć notatkę według identyfikatora z tabeli, użyj poniższego kodu.

stały usuńUwagę = (wymagane, odp.) => {
próbować {
stały { id } = wymagane.params;
 klient.zapytanie("USUŃ Z notatek GDZIE id=$1", [id], (błąd, dane) => {
jeśli (błądzić) rzucić błądzić;
res.status(200).json({
 błąd: zero,
 wiadomość: "Notatka usunięta",
 });
 });
 } złapać (błąd) {
res.status(500).json({
błąd: błąd.wiadomość,
 wiadomość: "Nie udało się usunąć notatki",
 });
 }
};

Teraz, po utworzeniu wszystkich funkcji CRUD, wyeksportuj je.

W helper.js dodaj następujące.

moduł.eksport = { createNote, getNotes, getNoteById, updateNoteById, deleteNote };

Zaimportujesz je w index.js podczas tworzenia punktów końcowych API.

Twórz trasy API

Ostatnim krokiem jest utworzenie punktów końcowych API w index.js dla każdej operacji CRUD.

Zacznij od zaimportowania pliku helper.js.

stały db = wymagać("./pomocnik")

Następnie utwórz każdy punkt końcowy.

aplikacja.pobierz("/notes", db.getNotes);
aplikacja.pobierz("/note/:id", db.getNoteById);
aplikacja.put("/note/:id", db.updateNoteById);
aplikacja.post("/note", db.createNote);
aplikacja.usuń("/note/:id", db.deleteNote);

REST API do aktualizacji bazy danych

Gdy skończysz, możesz sprawdzić, czy Twój interfejs API działa, używając klienta REST, takiego jak Postman, lub pisząc testy jednostkowe. Powinieneś być w stanie upewnić się, że wszystkie pięć punktów końcowych działa zgodnie z oczekiwaniami.

Możesz także sprawdzać i zarządzać danymi dodanymi do bazy danych za pomocą narzędzia pgAdmin. Jest to aplikacja GUI, która ułatwia administrowanie bazą danych i interakcję z serwerami PostgreSQL.