Un'API CRUD gestisce i dati attraverso quattro operazioni di base del database: creazione, lettura, aggiornamento ed eliminazione. Puoi creare una semplice API CRUD con solo Express e un database PostgreSQL.

Inizia creando un server Express a cui collegherai PostgreSQL. Quindi, crea le funzioni CRUD e collegale agli endpoint API. Una volta fatto, sarai in grado di connettere Node a PostgreSQL ed eseguire query di database su ogni percorso.

Prerequisiti per la creazione dell'API

Per seguire questo tutorial, dovresti:

  • Installa Node sulla tua macchina.
  • Installa il server PostgreSQL sulla tua macchina.
  • Avere una conoscenza di base di Express.js.

Crea un server rapido

Per creare un server Express, inizia creando una nuova directory e inserendola:

note mkdir
CD Appunti

Quindi inizializza npm:

npm init -y

Questo comando genererà un pacchetto.json file nella cartella delle note. Infine, installa Express.

npm installare esprimere

Crea un nuovo file chiamato index.js e aggiungi il codice seguente.

cost espresso = 





instagram viewer


richiedere("esprimere");
cost app = espresso();
app.uso(esprimere.urlencoded({
 esteso: VERO
}));
app.uso(esprimere.json())
app.ascolta (3000, () => console.log("Ascolto sulla porta 3000"));

Questo creerà un nuovo server in ascolto sulla porta 3000.

Crea un database PostgreSQL

Esegui il comando seguente nel prompt dei comandi di psql per creare un database PostgreSQL chiamato noteb.

postgres=# CREA DATABASE noteb;

Esegui questo comando su elenca tutti i database Postgres e controlla di aver creato il database noteb:

postgres=# \l

Collegati al database

Cominciando dall'inizio, connetti la tua applicazione Node al server PostgreSQL. Puoi usare il modulo node-Postgres.

Eseguire quanto segue per installarlo tramite npm:

npm installare pag

Come buona pratica, connettiti al database in un file separato.

Crea un nuovo file chiamato db.js e aggiungi quanto segue.

cost {Cliente} = richiedere("pag");
cost { utente, host, database, password, porta } = richiedere("./dbConfig");
cost cliente = nuovo Cliente({
 utente,
 ospite,
 Banca dati,
 parola d'ordine,
 porta,
});
cliente.Collegare();
modulo.esportazioni = cliente;

Qui stai esportando la stringa di connessione che utilizzerai per comunicare al database. Nota che stai leggendo le impostazioni di connessione al database da un file di configurazione chiamato dbConfig.js. Pertanto, crea dbConfig.js e aggiungi i seguenti dati.

modulo.esportazioni = {
 utente: "{dbUser}",
 ospite: "{dbHost}",
 Banca dati: "notatob",
 parola d'ordine: "{dbPassword}",
 porto: 5432,
};

Ricordarsi di sostituire i dettagli del database con i propri valori locali.

Crea una tabella PostgreSQL

Nel prompt dei comandi di psql, crea una tabella denominata note. Per cominciare, connettiti al database noteb usando il comando \c.

postgres=# \c notatob

Quindi, crea una tabella nel database connesso utilizzando il comando CREATE TABLE.

notatob=# CREA TABELLA note (
 CHIAVE PRIMARIA SERIALE ID,
 nota VARCHAR(255)
);

Questa tabella è abbastanza semplice. Ha solo un ID che è una chiave primaria generata automaticamente e un campo di testo chiamato nota.

Crea una nota

Invece di eseguire le operazioni CRUD nei percorsi, creare funzioni che interagiranno con il database in un file separato.

Crea un file di supporto chiamato helper.js e importare l'oggetto connessione da db.js.

cost cliente = richiedere("./db");

Utilizzare il codice seguente per creare la funzione createNote().

cost createNote = (req, res) => {
Tentativo {
cost { nota } = corpo richiesto;
se (! nota) {
gettareErrore("Invia nota in organismo di richiesta");
 }
cliente.interrogazione(
 "INSERIREIN note (nota) I VALORI ($1)",
[Nota],
 (err, dati) => {
ris.stato(201).json({
 errore: nullo,
 Messaggio: "Nuova nota creata",
 });
 }
 );
 } presa (errore) {
ris.stato(500).json({
errore: errore.Messaggio,
 messaggio: "Impossibile crearenuovo Nota",
 });
 }
};

Questa funzione verifica innanzitutto se il corpo della richiesta includeva una nota. Se la nota è assente, genera un errore.

Per creare una nota, la funzione utilizza la clausola INSERT. Restituisce un oggetto JSON contenente un messaggio di errore nullo e un messaggio di successo in caso di esito positivo.

Ottieni tutte le note

Per ottenere tutte le note dalla tabella, utilizzare la clausola SELECT *.

cost getNotes = (req, res) => {
Tentativo {
 client.query("SELEZIONA * DA note", (err, dati) => {
Se (errare) gettare erra;
ris.stato(200).json({
 ehm: nullo,
Appunti: dati.righe,
 });
 });
 } presa (errore) {
ris.stato(500).json({
err: errore.Messaggio,
 Appunti: nullo,
 });
 }
};

getNotes() invia l'array note nell'oggetto risposta se la query ha esito positivo.

Ottieni nota per ID

L'API avrà anche un endpoint che restituisce una nota in base all'ID. In helper.js, aggiungi una funzione getNoteById().

cost getNoteById = (req, res) => {
Tentativo {
cost { id } = parametri richiesti;
 client.query("SELEZIONA * DA note DOVE id=$1", [id], (err, dati) => {
Se (errare) gettare erra;
ris.stato(200).json({
 ehm: nullo,
Nota: dati.righe[0],
 });
 });
 } presa (errore) {
ris.stato(500).json({
err: err.Messaggio,
 Nota: nullo,
 });
 }
};

Questa funzione restituirà un oggetto JSON contenente la nota e un oggetto di errore.

Aggiorna nota per ID

Per aggiornare una nota, hai bisogno di una nota e dell'ID di quella nota. Riceverai la nota dal corpo della richiesta e l'ID dall'URL.

La funzione updateNoteById() utilizza la clausola UPDATE per aggiornare una nota esistente con una nuova nota.

cost updateNoteById = (req, res) => {
Tentativo {
cost { id } = parametri richiesti;
cost { nota } = corpo richiesto;
cliente.interrogazione(
 "AGGIORNARE Appunti IMPOSTARE nota = $1DOVEid = $2",
[nota, id],
 (err, dati) => {
Se (errare) gettare erra;
ris.stato(201).json({
 ehm: nullo,
 Messaggio: "Nota aggiornata",
 });
 }
 );
 } presa (errore) {
ris.stato(500).json({
err: errore.Messaggio,
 Messaggio: "Impossibile aggiornare la nota",
 });
 }
};

Questa funzione restituisce un messaggio di successo se la tabella viene aggiornata e un messaggio di errore in caso contrario.

Elimina nota per ID

Per eliminare una nota per ID dalla tabella, utilizzare il codice seguente.

cost deleteNote = (req, res) => {
Tentativo {
cost { id } = parametri richiesti;
 client.query("ELIMINA DA note DOVE id=$1", [id], (err, dati) => {
Se (errare) gettare erra;
ris.stato(200).json({
 errore: nullo,
 Messaggio: "Nota cancellata",
 });
 });
 } presa (errore) {
ris.stato(500).json({
errore: errore.Messaggio,
 Messaggio: "Impossibile eliminare la nota",
 });
 }
};

Ora che hai creato tutte le funzioni CRUD, esportale.

In helper.js, aggiungi quanto segue.

modulo.esportazioni = { createNote, getNotes, getNoteById, updateNoteById, deleteNote };

Li importerai index.js durante la creazione degli endpoint API.

Crea percorsi API

Il passaggio finale consiste nel creare endpoint API in index.js per ciascuna delle operazioni CRUD.

Inizia importando il file helper.js.

cost db = richiedere("./aiutante")

Quindi, crea ogni endpoint.

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);

Un'API REST per aggiornare il tuo database

Una volta terminato, puoi verificare che la tua API funzioni utilizzando un client REST come Postman o scrivendo unit test. Dovresti essere in grado di assicurarti che tutti i cinque endpoint funzionino come previsto.

Puoi anche controllare e gestire i dati che hai aggiunto al database usando lo strumento pgAdmin. È un'applicazione GUI che semplifica l'amministrazione del database e l'interazione con i server PostgreSQL.