En CRUD API administrerer data gennem fire grundlæggende databaseoperationer: oprette, læse, opdatere og slette. Du kan oprette en simpel CRUD API med kun Express og en PostgreSQL-database.

Start med at oprette en Express-server, som du vil forbinde PostgreSQL til. Opret derefter CRUD-funktionerne og tilslut dem til API-endepunkter. Når du har gjort det, vil du være i stand til at forbinde Node til PostgreSQL og udføre databaseforespørgsler på hver rute.

Forudsætninger for opbygning af API

For at følge med i denne tutorial skal du:

  • Installer Node på din maskine.
  • Installer PostgreSQL-serveren på din maskine.
  • Har et grundlæggende kendskab til Express.js.

Opret en Express Server

Til oprette en Express-server, start med at oprette en ny mappe og indtaste den:

mkdir noter
cd noter

Initialiser derefter npm:

npm init -y

Denne kommando vil generere en package.json fil i notemappen. Til sidst skal du installere Express.

npm installere udtrykke

Opret en ny fil kaldet index.js og tilføje følgende kode.

konst





instagram viewer

 udtrykke = kræve("udtryk");
konst app = express();
app.brug(udtrykke.urlencoded({
 udvidet: rigtigt
}));
app.brug(udtrykke.json())
app.listen (3000, () => console.log("Lytter på port 3000"));

Dette vil oprette en ny server, der lytter ved port 3000.

Opret en PostgreSQL-database

Udfør følgende kommando i psql-kommandoprompten for at oprette en PostgreSQL-database kaldet notedb.

postgres=# CREATE DATABASE notedb;

Kør denne kommando til liste alle Postgres databaser og kontroller, at du har oprettet notedb-databasen:

postgres=# \l

Opret forbindelse til databasen

Første ting først, tilslut din Node-applikation til PostgreSQL-serveren. Du kan bruge node-Postgres-modulet.

Kør følgende for at installere det via npm:

npm installere pg

Som god praksis skal du oprette forbindelse til databasen i en separat fil.

Opret en ny fil kaldet db.js og tilføje følgende.

konst { Klient } = kræve("pg");
konst { bruger, vært, database, adgangskode, port } = kræve("./dbConfig");
konst klient = ny Klient({
 bruger,
 vært,
 database,
 adgangskode,
 Havn,
});
klient.Opret forbindelse();
modul.eksport = klient;

Her eksporterer du forbindelsesstrengen, som du skal bruge til at kommunikere til databasen. Bemærk, at du læser databaseforbindelsesindstillingerne fra en konfigurationsfil kaldet dbConfig.js. Derfor skal du oprette dbConfig.js og tilføje følgende data til det.

modul.eksport = {
 bruger: "{dbUser}",
 vært: "{dbHost}",
 database: "noteretb",
 adgangskode: "{dbPassword}",
 port: 5432,
};

Husk at erstatte databasedetaljerne med dine egne lokale værdier.

Opret en PostgreSQL-tabel

I psql-kommandoprompten skal du oprette en tabel kaldet noter. Til at starte med skal du oprette forbindelse til notedb-databasen med kommandoen \c.

postgres=# \c bemærketb

Opret derefter en tabel i den tilsluttede database ved hjælp af CREATE TABLE-kommandoen.

noteretb=# OPRET TABEL noter (
 ID SERIEPRIMÆR NØGLE,
 bemærk VARCHAR(255)
);

Dette bord er ret simpelt. Den har kun et ID, som er en autogenereret primærnøgle og et tekstfelt kaldet note.

Opret en note

I stedet for at udføre CRUD-operationerne i ruterne, skal du oprette funktioner, der interagerer med databasen i en separat fil.

Opret en hjælpefil kaldet helper.js og importer forbindelsesobjektet fra db.js.

konst klient = kræve("./db");

Brug følgende kode til at oprette funktionen createNote().

konst createNote = (req, res) => {
prøve {
konst { note } = req.body;
if (!bemærk) {
kasteFejl("Send note i anmodningsorgan");
 }
klient.forespørgsel(
 "INDSÆTIND I noter (note) VÆRDIER ($1)",
[Bemærk],
 (fejl, data) => {
res.status(201).json({
 fejl: nul,
 besked: "Oprettet ny note",
 });
 }
 );
 } fangst (fejl) {
res.status(500).json({
fejl: fejl.besked,
 besked: "Det lykkedes ikke skabny Bemærk",
 });
 }
};

Denne funktion kontrollerer først, om anmodningsteksten indeholdt en note. Hvis noten er fraværende, giver den en fejl.

For at oprette en note bruger funktionen INSERT-sætningen. Det returnerer et JSON-objekt, der indeholder en null-fejlmeddelelse og en succesmeddelelse, hvis den lykkes.

Hent alle noter

For at få alle noterne fra tabellen, brug SELECT *-sætningen.

konst getNotes = (req, res) => {
prøve {
 klient.forespørgsel("VÆLG * FRA noter", (fejl, data) => {
hvis (fejl) kaste fejl;
res.status(200).json({
 fejl: nul,
noter: data.rækker,
 });
 });
 } fangst (fejl) {
res.status(500).json({
fejl: fejl.besked,
 noter: nul,
 });
 }
};

getNotes() sender notes-arrayet i responsobjektet, hvis forespørgslen er vellykket.

Få notat med ID

API'en vil også have et slutpunkt, der returnerer en note efter ID. Tilføj en getNoteById() funktion i helper.js.

konst getNoteById = (req, res) => {
prøve {
konst { id } = req.params;
 klient.forespørgsel("VÆLG * FRA noter WHERE id=$1", [id], (fejl, data) => {
hvis (fejl) kaste fejl;
res.status(200).json({
 fejl: nul,
Bemærk: data.rækker[0],
 });
 });
 } fangst (fejl) {
res.status(500).json({
fejl: fejl.besked,
 Bemærk: nul,
 });
 }
};

Denne funktion returnerer et JSON-objekt, der indeholder noten og et fejlobjekt.

Opdater note efter ID

For at opdatere en note skal du bruge en note og notens ID. Du får noten fra anmodningsteksten og ID'et fra URL'en.

Funktionen updateNoteById() bruger UPDATE-sætningen til at opdatere en eksisterende note med en ny note.

konst updateNoteById = (req, res) => {
prøve {
konst { id } = req.params;
konst { note } = req.body;
klient.forespørgsel(
 "OPDATERING noter SÆT note = $1HVORid = $2",
[note, id],
 (fejl, data) => {
hvis (fejl) kaste fejl;
res.status(201).json({
 fejl: nul,
 besked: "Opdateret note",
 });
 }
 );
 } fangst (fejl) {
res.status(500).json({
fejl: fejl.besked,
 besked: "Noten kunne ikke opdateres",
 });
 }
};

Denne funktion returnerer en succesmeddelelse, hvis tabellen er opdateret, og en fejlmeddelelse, hvis den ikke er det.

Slet note efter ID

Brug følgende kode for at slette en note efter ID fra tabellen.

konst deleteNote = (req, res) => {
prøve {
konst { id } = req.params;
 klient.forespørgsel("SLET FRA noter WHERE id=$1", [id], (fejl, data) => {
hvis (fejl) kaste fejl;
res.status(200).json({
 fejl: nul,
 besked: "Note slettet",
 });
 });
 } fangst (fejl) {
res.status(500).json({
fejl: fejl.besked,
 besked: "Noten kunne ikke slettes",
 });
 }
};

Nu hvor du har oprettet alle CRUD-funktionerne, skal du eksportere dem.

Tilføj følgende i helper.js.

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

Du importerer dem ind index.js når du opretter API-endepunkterne.

Opret API-ruter

Det sidste trin er at oprette API-endepunkter i index.js for hver af CRUD-operationerne.

Begynd med at importere helper.js-filen.

konst db = kræve("./hjælper")

Opret derefter hvert slutpunkt.

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

En REST API til at opdatere din database

Når du er færdig, kan du kontrollere, at din API fungerer ved at bruge en REST-klient som Postman, eller ved at skrive enhedstests. Du bør være i stand til at sikre, at de fem endepunkter alle fungerer, som du forventer.

Du kan også inspicere og administrere de data, du har føjet til databasen, ved hjælp af pgAdmin-værktøjet. Det er en GUI-applikation, der gør det nemt at udføre databaseadministration og interagere med PostgreSQL-servere.