Ett CRUD API hanterar data genom fyra grundläggande databasoperationer: skapa, läsa, uppdatera och ta bort. Du kan skapa ett enkelt CRUD API med bara Express och en PostgreSQL-databas.

Börja med att skapa en Express-server som du ansluter PostgreSQL till. Skapa sedan CRUD-funktionerna och koppla upp dem till API-slutpunkter. När du har gjort det kommer du att kunna ansluta Node till PostgreSQL och utföra databasfrågor på varje rutt.

Förutsättningar för att bygga API

För att följa med i denna handledning bör du:

  • Installera Node på din maskin.
  • Installera PostgreSQL-servern på din maskin.
  • Ha grundläggande kunskaper om Express.js.

Skapa en Express-server

Till skapa en Express-server, börja med att skapa en ny katalog och ange den:

mkdir anteckningar
CD anteckningar

Initiera sedan npm:

npm init -y

Detta kommando kommer att generera en package.json filen i mappen anteckningar. Slutligen, installera Express.

npm Installera uttrycka

Skapa en ny fil som heter index.js och lägg till följande kod.

konst uttrycka = 





instagram viewer


behöva("uttrycka");
konst app = express();
app.använda sig av(uttrycka.urlenkodad({
 utökad: Sann
}));
app.använda sig av(uttrycka.json())
app.listen (3000, () => console.log("Lyssnar på port 3000"));

Detta kommer att skapa en ny server som lyssnar på port 3000.

Skapa en PostgreSQL-databas

Utför följande kommando i psql-kommandotolken för att skapa en PostgreSQL-databas som heter notedb.

postgres=# SKAPA DATABAS notedb;

Kör detta kommando till lista alla Postgres-databaser och kontrollera att du skapade notedb-databasen:

postgres=# \l

Anslut till databasen

Först till kvarn, anslut din Node-applikation till PostgreSQL-servern. Du kan använda nod-Postgres-modulen.

Kör följande för att installera det via npm:

npm Installera sid

Som god praxis kan du ansluta till databasen i en separat fil.

Skapa en ny fil som heter db.js och lägg till följande.

konst { Client } = behöva("pg");
konst { användare, värd, databas, lösenord, port } = behöva("./dbConfig");
konst klient = ny Klient({
 användare,
 värd,
 databas,
 Lösenord,
 hamn,
});
klient.ansluta();
modul.export = klient;

Här exporterar du anslutningssträngen som du ska använda för att kommunicera till databasen. Observera att du läser databasanslutningsinställningarna från en konfigurationsfil som heter dbConfig.js. Skapa därför dbConfig.js och lägg till följande data till den.

modul.export = {
 användare: "{dbAnvändare}",
 värd: "{dbHost}",
 databas: "noteratb",
 Lösenord: "{dbPassword}",
 hamn: 5432,
};

Kom ihåg att ersätta databasdetaljerna med dina egna lokala värden.

Skapa en PostgreSQL-tabell

Skapa en tabell som heter notes i psql-kommandotolken. Till att börja med, anslut till notedb-databasen med kommandot \c.

postgres=# \c noteratb

Skapa sedan en tabell i den anslutna databasen med kommandot CREATE TABLE.

notedb=# SKAPA TABELL anteckningar (
 ID SERIAL PRIMÄR NYCKEL,
 not VARCHAR(255)
);

Detta bord är ganska enkelt. Den har bara ett ID som är en autogenererad primärnyckel och ett textfält som kallas note.

Skapa en anteckning

Istället för att utföra CRUD-operationerna i rutterna, skapa funktioner som kommer att interagera med databasen i en separat fil.

Skapa en hjälpfil som heter helper.js och importera anslutningsobjektet från db.js.

konst klient = behöva("./db");

Använd följande kod för att skapa funktionen createNote().

konst createNote = (req, res) => {
Prova {
konst { not } = req.body;
if (!not) {
kastaFel("Skicka anteckning i begäran organ");
 }
klient.fråga(
 "FÖRA ININ I anteckningar (not) VÄRDEN ($1)",
[notera],
 (fel, data) => {
res.status(201).json({
 fel: null,
 meddelande: "Skapat en ny anteckning",
 });
 }
 );
 } fånga (fel) {
res.status(500).json({
fel: fel.meddelande,
 meddelande: "Det gick inte att skapany notera",
 });
 }
};

Denna funktion kontrollerar först om förfrågningsorganet inkluderade en anteckning. Om anteckningen är frånvarande ger den ett fel.

För att skapa en anteckning använder funktionen INSERT-satsen. Det returnerar ett JSON-objekt som innehåller ett null-felmeddelande och ett framgångsmeddelande om det lyckas.

Få alla anteckningar

För att få alla anteckningar från tabellen, använd SELECT *-satsen.

konst getNotes = (req, res) => {
Prova {
 client.query("VÄLJ * FRÅN anteckningar", (fel, data) => {
om (fela) kasta fela;
res.status(200).json({
 fela: null,
anteckningar: data.rader,
 });
 });
 } fånga (fel) {
res.status(500).json({
fela: fel.meddelande,
 anteckningar: null,
 });
 }
};

getNotes() skickar notes-arrayen i responsobjektet om frågan lyckas.

Få anteckning med ID

API: et kommer också att ha en slutpunkt som returnerar en anteckning per ID. Lägg till en getNoteById() funktion i helper.js.

konst getNoteById = (req, res) => {
Prova {
konst { id } = req.params;
 client.query("SELECT * FROM notes WHERE id=$1", [id], (fel, data) => {
om (fela) kasta fela;
res.status(200).json({
 fela: null,
notera: data.rader[0],
 });
 });
 } fånga (fel) {
res.status(500).json({
fela: fela.meddelande,
 notera: null,
 });
 }
};

Den här funktionen returnerar ett JSON-objekt som innehåller anteckningen och ett felobjekt.

Uppdatera anteckning efter ID

För att uppdatera en anteckning behöver du en anteckning och anteckningens ID. Du kommer att få anteckningen från förfrågan och ID från URL: en.

Funktionen updateNoteById() använder UPDATE-satsen för att uppdatera en befintlig anteckning med en ny anteckning.

konst updateNoteById = (req, res) => {
Prova {
konst { id } = req.params;
konst { not } = req.body;
klient.fråga(
 "UPPDATERING anteckningar UPPSÄTTNING not = $1VARid = $2",
[nota, id],
 (fel, data) => {
om (fela) kasta fela;
res.status(201).json({
 fela: null,
 meddelande: "Uppdaterad anteckning",
 });
 }
 );
 } fånga (fel) {
res.status(500).json({
fela: fel.meddelande,
 meddelande: "Det gick inte att uppdatera anteckningen",
 });
 }
};

Den här funktionen returnerar ett framgångsmeddelande om tabellen uppdateras och ett felmeddelande om det inte är det.

Ta bort anteckning med ID

Använd följande kod för att radera en anteckning med ID från tabellen.

konst deleteNote = (req, res) => {
Prova {
konst { id } = req.params;
 client.query("DELETE FROM notes WHERE id=$1", [id], (fel, data) => {
om (fela) kasta fela;
res.status(200).json({
 fel: null,
 meddelande: "Anteckningen raderad",
 });
 });
 } fånga (fel) {
res.status(500).json({
fel: fel.meddelande,
 meddelande: "Det gick inte att ta bort anteckningen",
 });
 }
};

Nu när du har skapat alla CRUD-funktioner, exportera dem.

Lägg till följande i helper.js.

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

Du kommer att importera dem index.js när du skapar API-slutpunkterna.

Skapa API-rutter

Det sista steget är att skapa API-slutpunkter i index.js för var och en av CRUD-operationerna.

Börja med att importera helper.js-filen.

konst db = behöva("./hjälpare")

Skapa sedan varje 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);

Ett REST API för att uppdatera din databas

När du är klar kan du kontrollera att ditt API fungerar genom att använda en REST-klient som Postman, eller genom att skriva enhetstester. Du bör kunna säkerställa att de fem ändpunkterna alla fungerar som du förväntar dig.

Du kan också inspektera och hantera data som du lagt till i databasen med hjälp av verktyget pgAdmin. Det är en GUI-applikation som gör det enkelt att utföra databasadministration och interagera med PostgreSQL-servrar.