Et CRUD API administrerer data gjennom fire grunnleggende databaseoperasjoner: opprette, lese, oppdatere og slette. Du kan lage en enkel CRUD API med kun Express og en PostgreSQL-database.

Start med å lage en Express-server som du kobler PostgreSQL til. Deretter oppretter du CRUD-funksjonene og kobler dem til API-endepunkter. Når du har gjort det, vil du kunne koble Node til PostgreSQL og utføre databasespørringer på hver rute.

Forutsetninger for å bygge API

For å følge med på denne opplæringen, bør du:

  • Installer Node på maskinen din.
  • Installer PostgreSQL-serveren på maskinen din.
  • Ha grunnleggende kunnskap om Express.js.

Opprett en ekspressserver

Til opprette en Express-server, begynn med å opprette en ny katalog og angi den:

mkdir notater
cd notater

Initialiser deretter npm:

npm init -y

Denne kommandoen vil generere en package.json filen i notatmappen. Til slutt, installer Express.

npm installere uttrykke

Opprett en ny fil kalt index.js og legg til følgende kode.

konst uttrykke = krever("uttrykke");
konst app = express();
app.bruk(uttrykke.urlencoded({
 forlenget: ekte
}));
app.bruk(uttrykke.json())
app.listen (3000, () => console.log("Lytter på port 3000"));

Dette vil opprette en ny server som lytter på port 3000.

Opprett en PostgreSQL-database

Utfør følgende kommando i psql-ledeteksten for å opprette en PostgreSQL-database kalt notedb.

postgres=# LAG DATABASE notedb;

Kjør denne kommandoen til liste opp alle Postgres-databasene og sjekk at du opprettet notedb-databasen:

postgres=# \l

Koble til databasen

Første ting først, koble Node-applikasjonen til PostgreSQL-serveren. Du kan bruke node-Postgres-modulen.

Kjør følgende for å installere den via npm:

npm installere s

Som god praksis, koble til databasen i en egen fil.

Opprett en ny fil kalt db.js og legg til følgende.

konst { Klient } = krever("pg");
konst { bruker, vert, database, passord, port } = krever("./dbConfig");
konst klient = ny Klient({
 bruker,
 vert,
 database,
 passord,
 havn,
});
klient.koble();
modul.eksport = klient;

Her eksporterer du tilkoblingsstrengen som du skal bruke til å kommunisere til databasen. Merk at du leser innstillingene for databasetilkobling fra en konfigurasjonsfil kalt dbConfig.js. Opprett derfor dbConfig.js og legg til følgende data til den.

modul.eksport = {
 bruker: "{dbUser}",
 vert: "{dbHost}",
 database: "notertb",
 passord: "{dbPassword}",
 port: 5432,
};

Husk å erstatte databasedetaljene med dine egne lokale verdier.

Lag en PostgreSQL-tabell

I psql-ledeteksten oppretter du en tabell kalt notater. Til å begynne med, koble til notedb-databasen ved å bruke kommandoen \c.

postgres=# \c notertb

Deretter oppretter du en tabell i den tilkoblede databasen ved å bruke CREATE TABLE-kommandoen.

notertb=# LAG TABELL notater (
 ID SERIEPRIMÆR NØKKEL,
 merk VARCHAR(255)
);

Dette bordet er ganske enkelt. Den har bare en ID som er en autogenerert primærnøkkel og et tekstfelt kalt notat.

Lag et notat

I stedet for å utføre CRUD-operasjonene i rutene, lag funksjoner som vil samhandle med databasen i en egen fil.

Lag en hjelpefil kalt helper.js og importer tilkoblingsobjektet fra db.js.

konst klient = krever("./db");

Bruk følgende kode for å lage createNote()-funksjonen.

konst createNote = (req, res) => {
prøve {
konst { note } = req.body;
if (!note) {
kasteFeil("Send notat i forespørselsorgan");
 }
klient.spørsmål(
 "SETT INNINN I notater (merknad) VERDIER ($1)",
[Merk],
 (feil, data) => {
res.status(201).json({
 feil: null,
 beskjed: "Laget nytt notat",
 });
 }
 );
 } å fange (feil) {
res.status(500).json({
feil: feil.beskjed,
 melding: "Kunnet ikke skapeny Merk",
 });
 }
};

Denne funksjonen sjekker først om forespørselsteksten inkluderte en merknad. Hvis notatet er fraværende, gir det en feil.

For å lage et notat bruker funksjonen INSERT-leddet. Den returnerer et JSON-objekt som inneholder en null-feilmelding og en suksessmelding hvis vellykket.

Få alle notater

For å få alle notatene fra tabellen, bruk SELECT *-leddet.

konst getNotes = (req, res) => {
prøve {
 client.query("VELG * FRA notater", (feil, data) => {
hvis (feil) kaste feile;
res.status(200).json({
 feil: null,
notater: data.rader,
 });
 });
 } å fange (feil) {
res.status(500).json({
feil: feil.beskjed,
 merknader: null,
 });
 }
};

getNotes() sender notes-matrisen i responsobjektet hvis spørringen er vellykket.

Få notat med ID

API-en vil også ha et endepunkt som returnerer et notat etter ID. I helper.js legger du til en getNoteById()-funksjon.

konst getNoteById = (req, res) => {
prøve {
konst { id } = req.params;
 client.query("VELG * FRA notater WHERE id=$1", [id], (feil, data) => {
hvis (feil) kaste feile;
res.status(200).json({
 feil: null,
Merk: data.rader[0],
 });
 });
 } å fange (feil) {
res.status(500).json({
feil: feil.beskjed,
 Merk: null,
 });
 }
};

Denne funksjonen vil returnere et JSON-objekt som inneholder notatet og et feilobjekt.

Oppdater notat etter ID

For å oppdatere et notat trenger du et notat og ID-en til det notatet. Du vil få notatet fra forespørselsteksten og ID-en fra URL-en.

UpdateNoteById()-funksjonen bruker UPDATE-leddet for å oppdatere et eksisterende notat med et nytt notat.

konst updateNoteById = (req, res) => {
prøve {
konst { id } = req.params;
konst { note } = req.body;
klient.spørsmål(
 "OPPDATER notater SETT notat = $1HVORid = $2",
[merknad, id],
 (feil, data) => {
hvis (feil) kaste feile;
res.status(201).json({
 feil: null,
 beskjed: "Oppdatert notat",
 });
 }
 );
 } å fange (feil) {
res.status(500).json({
feil: feil.beskjed,
 beskjed: "Kunne ikke oppdatere notatet",
 });
 }
};

Denne funksjonen returnerer en suksessmelding hvis tabellen er oppdatert og en feilmelding hvis den ikke er det.

Slett notat etter ID

For å slette et notat etter ID fra tabellen, bruk følgende kode.

konst deleteNote = (req, res) => {
prøve {
konst { id } = req.params;
 client.query("SLETT FRA notater WHERE id=$1", [id], (feil, data) => {
hvis (feil) kaste feile;
res.status(200).json({
 feil: null,
 beskjed: "Merknad slettet",
 });
 });
 } å fange (feil) {
res.status(500).json({
feil: feil.beskjed,
 beskjed: "Kunne ikke slette notatet",
 });
 }
};

Nå som du har opprettet alle CRUD-funksjonene, eksporter dem.

I helper.js legger du til følgende.

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

Du vil importere dem inn index.js når du oppretter API-endepunktene.

Lag API-ruter

Det siste trinnet er å lage API-endepunkter i index.js for hver av CRUD-operasjonene.

Begynn med å importere helper.js-filen.

konst db = krever("./hjelper")

Deretter oppretter du hvert endepunkt.

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 for å oppdatere databasen din

Når du er ferdig, kan du sjekke at API-en din fungerer ved å bruke en REST-klient som Postman, eller ved å skrive enhetstester. Du bør være i stand til å sikre at de fem endepunktene alle fungerer som du forventer.

Du kan også inspisere og administrere dataene du har lagt til databasen ved å bruke pgAdmin-verktøyet. Det er en GUI-applikasjon som gjør det enkelt å utføre databaseadministrasjon og samhandle med PostgreSQL-servere.