O API CRUD gestionează datele prin patru operațiuni de bază ale bazei de date: crearea, citirea, actualizarea și ștergerea. Puteți crea un API CRUD simplu cu doar Express și o bază de date PostgreSQL.

Începeți prin a crea un server Express la care vă veți conecta PostgreSQL. Apoi, creați funcțiile CRUD și conectați-le la punctele finale API. Odată ce ați făcut acest lucru, veți putea să conectați Node la PostgreSQL și să efectuați interogări la baza de date pe fiecare rută.

Cerințe preliminare pentru construirea API-ului

Pentru a urma acest tutorial, ar trebui să:

  • Instalați Node pe mașina dvs.
  • Instalați serverul PostgreSQL pe mașina dvs.
  • Să aibă cunoștințe de bază despre Express.js.

Creați un server Express

La creați un server Express, începeți prin a crea un nou director și introduceți-l:

note mkdir
CD note

Apoi inițializați npm:

npm init -y

Această comandă va genera a pachet.json fișier în folderul de note. În cele din urmă, instalați Express.

npm instalare expres

Creați un fișier nou numit index.js și adăugați următorul cod.

instagram viewer 
const expres = cere("expres");
const aplicație = expres();
aplicația.utilizare(expres.urlencoded({
 extins: Adevărat
}));
aplicația.utilizare(expres.json())
app.ascultă (3000, () => console.log("Ascult pe portul 3000"));

Acest lucru va crea un nou server care ascultă la portul 3000.

Creați o bază de date PostgreSQL

Executați următoarea comandă în promptul de comandă psql pentru a crea o bază de date PostgreSQL numită notedb.

postgres=# CREATE DATABASE notatb;

Rulați această comandă către listează toate bazele de date Postgres și verificați dacă ați creat baza de date notedb:

postgres=# \l

Conectați-vă la baza de date

Să începem cu începutul, conectați aplicația dvs. Node la serverul PostgreSQL. Puteți utiliza modulul node-Postgres.

Rulați următoarele pentru a-l instala prin npm:

npm instalare pg

Ca bună practică, conectați-vă la baza de date într-un fișier separat.

Creați un fișier nou numit db.js și adăugați următoarele.

const { Client } = cere("pg");
const { utilizator, gazdă, bază de date, parolă, port } = cere(""./dbConfig");
const client = nou Client({
 utilizator,
 gazdă,
 Bază de date,
 parola,
 port,
});
client.conectați();
modul.exporturi = client;

Aici, exportați șirul de conexiune pe care îl veți folosi pentru a comunica cu baza de date. Rețineți că citiți setările de conexiune la baza de date dintr-un fișier de configurare numit dbConfig.js. Prin urmare, creați dbConfig.js și adăugați următoarele date la acesta.

modul.exporturi = {
 utilizator: "{dbUser}",
 gazdă: "{dbHost}",
 Bază de date: "notatb",
 parola: "{dbPassword}",
 port: 5432,
};

Nu uitați să înlocuiți detaliile bazei de date cu propriile valori locale.

Creați un tabel PostgreSQL

În linia de comandă psql, creați un tabel numit note. Pentru început, conectați-vă la baza de date notedb folosind comanda \c.

postgres=# \c notatb

Apoi, creați un tabel în baza de date conectată folosind comanda CREATE TABLE.

notatb=# CREATE TABLE note (
 ID SERIAL CHEIE PRIMARĂ,
 nota VARCHAR(255)
);

Acest tabel este destul de simplu. Are doar un ID care este o cheie primară generată automat și un câmp de text numit notă.

Creați o notă

În loc să efectuați operațiunile CRUD în rute, creați funcții care vor interacționa cu baza de date într-un fișier separat.

Creați un fișier de ajutor numit helper.js și importați obiectul de conexiune din db.js.

const client = cere(""./db");

Utilizați următorul cod pentru a crea funcția createNote().

const createNote = (req, res) => {
încerca {
const { notă } = req.body;
dacă (!notă) {
aruncaEroare("Trimite notă în organismul cererii");
 }
client.interogare(
 "INTRODUCEÎN note (notă) VALORI ($1)",
[Notă],
 (err, date) => {
res.stare(201).json({
 eroare: nul,
 mesaj: "S-a creat o nouă notă",
 });
 }
 );
 } captură (eroare) {
res.stare(500).json({
eroare: eroare.mesaj,
 mesaj: „Eșuat creanou Notă",
 });
 }
};

Această funcție verifică mai întâi dacă corpul cererii a inclus o notă. Dacă nota este absentă, se afișează o eroare.

Pentru a crea o notă, funcția folosește clauza INSERT. Returnează un obiect JSON care conține un mesaj de eroare nul și un mesaj de succes dacă are succes.

Obțineți toate notele

Pentru a obține toate notele din tabel, utilizați clauza SELECT *.

const getNotes = (req, res) => {
încerca {
 client.query("SELECTAȚI * DIN note", (err, date) => {
dacă (eroare) arunca a greșit;
res.stare(200).json({
 greseala: nul,
note: date.rânduri,
 });
 });
 } captură (eroare) {
res.stare(500).json({
a greșit: eroare.mesaj,
 note: nul,
 });
 }
};

getNotes() trimite matricea de note în obiectul răspuns dacă interogarea are succes.

Obțineți notă după ID

API-ul va avea, de asemenea, un punct final care returnează o notă după ID. În helper.js, adăugați o funcție getNoteById().

const getNoteById = (req, res) => {
încerca {
const { id } = req.params;
 client.query("SELECTAȚI * DIN note WHERE id=$1", [id], (err, date) => {
dacă (eroare) arunca a greșit;
res.stare(200).json({
 greseala: nul,
Notă: date.rânduri[0],
 });
 });
 } captură (eroare) {
res.stare(500).json({
a greșit: a greșit.mesaj,
 Notă: nul,
 });
 }
};

Această funcție va returna un obiect JSON care conține nota și un obiect de eroare.

Actualizați nota după ID

Pentru a actualiza o notă, aveți nevoie de o notă și de ID-ul notei respective. Veți primi nota de la corpul solicitării și ID-ul de la adresa URL.

Funcția updateNoteById() folosește clauza UPDATE pentru a actualiza o notă existentă cu o notă nouă.

const updateNoteById = (req, res) => {
încerca {
const { id } = req.params;
const { notă } = req.body;
client.interogare(
 "ACTUALIZAȚI note A STABILIT nota = $1UNDEid = $2",
[notă, id],
 (err, date) => {
dacă (eroare) arunca a greșit;
res.stare(201).json({
 greseala: nul,
 mesaj: "Notă actualizată",
 });
 }
 );
 } captură (eroare) {
res.stare(500).json({
a greșit: eroare.mesaj,
 mesaj: "Nu s-a putut actualiza nota",
 });
 }
};

Această funcție returnează un mesaj de succes dacă tabelul este actualizat și un mesaj de eroare dacă nu este.

Ștergeți nota după ID

Pentru a șterge o notă după ID din tabel, utilizați următorul cod.

const deleteNote = (req, res) => {
încerca {
const { id } = req.params;
 client.query("DELETE FROM note WHERE id=$1", [id], (err, date) => {
dacă (eroare) arunca a greșit;
res.stare(200).json({
 eroare: nul,
 mesaj: "Nota ștearsă",
 });
 });
 } captură (eroare) {
res.stare(500).json({
eroare: eroare.mesaj,
 mesaj: "Nu s-a șters nota",
 });
 }
};

Acum că ați creat toate funcțiile CRUD, exportați-le.

În helper.js, adăugați următoarele.

modul.exporturi = { createNote, getNotes, getNoteById, updateNoteById, deleteNote };

Le vei importa în index.js la crearea punctelor finale API.

Creați rute API

Pasul final este crearea punctelor finale API în index.js pentru fiecare dintre operațiunile CRUD.

Începeți prin a importa fișierul helper.js.

const db = cere("./ajutor")

Apoi, creați fiecare punct final.

app.get("/notes", db.getNotes);
app.get("/note/:id", db.getNoteById);
app.put("/note/:id", db.updateNoteById);
app.post("/note", db.createNote);
app.delete("/note/:id", db.deleteNote);

O API REST pentru a vă actualiza baza de date

După ce ați terminat, puteți verifica dacă API-ul dvs. funcționează utilizând un client REST precum Postman sau scriind teste unitare. Ar trebui să vă puteți asigura că toate cele cinci puncte finale funcționează așa cum vă așteptați.

De asemenea, puteți inspecta și gestiona datele pe care le-ați adăugat în baza de date folosind instrumentul pgAdmin. Este o aplicație GUI care facilitează administrarea bazei de date și interacțiunea cu serverele PostgreSQL.