Cum să creați un API NodeJS fără a utiliza un cadru

Node.js este un runtime JavaScript open-source construit pe motorul Chrome v8 care vă permite să rulați cod JavaScript în afara unui browser.

Modelul său de evenimente, ecosistemul și viteza au făcut din Node.js unul dintre cele mai căutate și utilizate timpi de execuție pentru aplicațiile de pe server.

Majoritatea serverelor API Node.js folosesc Express sau un alt cadru. Cu toate acestea, puteți crea și un simplu API Node.js fără un cadru în doar câțiva pași.

Pasul 1: Configurați-vă mediul de dezvoltare

Creați un director de proiect și CD în el rulând:

mkdir nodejs-api
CD nodejs-api

Apoi, inițializați npm în proiectul dvs. rulând:

npm init -y

Acest API CRUD va include utilizarea MongoDB, o bază de date NoSQL și popularul său ODM, mangusta.

Rulați următoarea comandă pentru a instala mangustă:

npm instalare mangustă

Apoi, creați un server.js fișier în directorul rădăcină al proiectului și adăugați blocul de cod de mai jos pentru a crea un server:

const http = cere("http");
const server = http.createServer((req, res) => {});
server.listen (3000, () => {
consolă.Buturuga(`Serverul rulează`);
});

Acest bloc de cod importă modulul http, un modul principal Node.js. Modulul http permite lui Node.js să transfere date prin HTTP. Acest modul conține metodele necesare pentru a crea un server.

Apoi, apelează modulul http createServer metodă care creează și returnează o instanță a unui server. The createServer metoda preia o funcție de apel invers cu un obiect de cerere și răspuns ca parametri.

Apoi, codul apelează asculta metoda pe instanța de server returnată. Acest lucru permite serverului să înceapă să asculte traficul pe portul dat. The asculta metoda declanșează un callback - al doilea argument - când reușește.

În cele din urmă, creați două directoare numite trasee și modele în directorul rădăcină al proiectului. The trasee folderul va conține logica de rutare pentru API-ul dvs., în timp ce model va contine tot ce este legat de baza de date.

Pasul 2: Conectarea aplicației la o bază de date

În server.js, import mangustă:

const mangusta = cere("mangustă");

Suna conectați metoda pe mangustă și transmiteți URI-ul dvs. MongoDB ca argument:

mangoose.connect("MongoDB_URI")

Pasul 3: Crearea unui model API

Creați un API CRUD pentru o aplicație simplă de blog. În dumneavoastră modele folder, creați un blogModel.js fișier și adăugați următorul cod la fișierul dvs.:

const mangusta = cere("mangustă");
const blogSchema = mangusta. Schemă({
 titlu: {
 tip: Şir,
 necesar: [adevărat, "Blogul trebuie să aibă un titlu"],
 },
 corp: {
 tip: Şir,
 necesar: [adevărat, "Blogul trebuie să aibă un corp"],
 },
});
modul.exporturi = mangoose.model("Blog", blogSchema);

Blocul de cod de mai sus creează un model de mangustă cu două proprietăți și le mapează la o bază de date MongoDB.

Ambele proprietăți din acest model au a Şir tip cu necesar setat la Adevărat. Mesajele de eroare însoțitoare se vor afișa dacă corpul unei cereri nu conține niciuna dintre proprietăți.

Linia finală creează și exportă un model de mangustă apelând la model metoda pe mangustă. Transmite numele modelului (Blog) ca prim argument și o schemă (BlogSchema) ca al doilea argument.

Pasul 4: Implementarea rutare în aplicația dvs

Fără ajutorul lui cadre precum Express, va trebui să creați manual logica pentru a gestiona fiecare solicitare făcută către API-ul dvs.

Mai întâi, creați un blogRoutes.js dosar în dvs trasee folder, apoi importați modelul blogului:

const Blog = cere(""../modele/blogModel");

Apoi, creați un asincron router funcţie, trecere solicitat și res ca parametri și exportați funcția:

const router = asincronfuncţie (cerere, res) {};
modul.exporturi = router;

Această funcție va conține toată logica de rutare.

În continuare, veți implementa ruta logică de rutare după rută.

GET rute

Adăugați blocul de cod de mai jos la dvs router funcția de implementare a OBȚINE handler de rută pentru solicitările făcute către /api/blogs:

// GET: /api/blogs
dacă (req.url "/api/blogs"&& req.metoda "OBȚINE") {
// obțineți toate blogurile
const bloguri = asteapta Blog.find();
// a stabilit cel stare cod șiconţinut-tip
 res.writeHead (200, { "Tipul de conținut": "aplicație/json" });
// trimite date
res.Sfârşit(JSON.stringe(bloguri));
}

Blocul de cod de mai sus verifică url și metodă proprietățile obiectului de cerere. Apoi preia toate blogurile din baza de date prin intermediul găsi metoda pe modelul mangusta (Blog).

Apoi, se numește scrie cap metoda pe res, obiectul răspuns. Această metodă trimite un antet de răspuns cu trei argumente: un cod de stare, un mesaj de stare opțional și anteturi. The 200 codul de stare reprezintă un răspuns de succes, iar tipul de conținut pentru acest apel API este setat la aplicație/json.

În cele din urmă, închideți cererea pentru a vă asigura că serverul nu se blochează apelând la Sfârşit metoda pe res. Apelul la JSON.stringify convertește bloguri obiect la un șir JSON și transmiterea acestuia către Sfârşit metoda returnează ca corp răspuns.

Adăugați blocul de cod de mai jos la dvs router funcția de implementare a OBȚINE handler de rută pentru o singură resursă:

// GET: /api/blogs/:id
dacă (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metoda "OBȚINE") {
încerca {
// extrage id din url
 const id = req.url.split("/")[3];
// obțineți blogul de la DB
const blog = asteapta Blog.findById (id);
dacă (blog) {
 res.writeHead (200, { "Tipul de conținut": "aplicație/json" });
res.Sfârşit(JSON.stringe(blog));
 } altfel {
aruncanouEroare(„Blogul nu există”);
 }
 } captură (eroare) {
 res.writeHead (404, { "Tipul de conținut": "aplicație/json" });
res.Sfârşit(JSON.stringe({ mesaj: eroare }));
 }
}

Acest cod folosește Meci metoda, care ia o expresie regex ca argument, pentru a verifica dacă adresa URL se potrivește cu formatul: /api/blogs/.

Apoi, extrageți id proprietate din url șir prin apelul său Despică metodă. Această metodă ia un model ca argument (/), împarte șirul pe baza modelului și returnează o matrice. Al treilea element al acestei matrice este id.

În cele din urmă, preluați documentul cu potrivirea id din baza ta de date. Dacă există, trimiteți un cod de răspuns de 200, închideți solicitarea și trimiteți blogul preluat. Dacă nu există, aruncați o eroare și trimiteți-o ca răspuns în blocul catch.

Ruta POST

Adăugați blocul de cod de mai jos la funcția de router pentru a implementa POST handler de rută:

// POST: /api/blogs/
dacă (req.url "/api/blogs"&& req.metoda "POST") {
încerca {
 lasă corpul = "";
// Ascultă evenimentul de date
 req.on("date", (bucătură) => {
 body += chunk.toString();
 });
// Asculta Sfârşiteveniment
 req.on("Sfârşit", asincron () => {
// Creați blog
lăsa blog = nou Blog(JSON.parse (corp));
// Salvați în DB
asteapta blog.save();
 res.writeHead (200, { "Tipul de conținut": "aplicație/json" });
res.Sfârşit(JSON.stringe(blog));
 });
 } captură (eroare) {
consolă.log (eroare);
 }
}

Obiectul cerere implementează Node.js ReadableStream interfata. Acest flux emite a date si un Sfârşit eveniment care vă oferă acces la datele de la organismul de solicitare.

Acest cod ascultă evenimentul de date și îl gestionează convertindu-l într-un șir și concatenându-l la corp variabil. În Sfârşit handler de evenimente, creează un Blog exemplu cu șirul de corp analizat. Apoi salvează noul blog, trimite codul de stare și antetul conținutului și închide solicitarea.

PUT Traseu

Adăugați blocul de cod de mai jos la funcția de router pentru a implementa A PUNE handler de rută:

// PUT: /api/blogs/:id
dacă (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metoda "A PUNE") {
încerca {
// extrage id din url
 const id = req.url.split("/")[3];
 lasă corpul = "";
req.on("date", (bucătură) => {
 body += chunk.toString();
 });
 req.on("Sfârşit", asincron () => {
 // Gaseste si Actualizațidocument
lăsa updatedBlog = asteapta Blog.findByIdAndUpdate (id, JSON.parse (corp), {
nou: Adevărat,
 });
res.writeHead (200, { "Tipul de conținut": "aplicație/json" });
res.Sfârşit(JSON.stringe(Blog actualizat));
 });
 } captură (eroare) {
consolă.log (eroare);
 }
}

Handler-ul cererii PUT este aproape identic cu POST handler de cereri, cu excepția faptului că extrage fișierul id proprietate din url pentru a actualiza blogul relevant.

DELETE Ruta

Adăugați blocul de cod de mai jos la funcția de router pentru a vă implementa ȘTERGE handler de rută:

// ȘTERGE: /api/blogs/:id
dacă (req.url.match(/\\/api\\/blogs\\/([0-9]+)/) && req.metoda "ȘTERGE") {
încerca {
 const id = req.url.split("/")[3];
// Șterge blog din DB
asteapta Blog.findByIdAndDelete (id);
 res.writeHead (200, { "Tipul de conținut": "aplicație/json" });
 res.end (JSON.stringify({ mesaj: "Blogul a fost șters cu succes" }));
 } captură (eroare) {
 res.writeHead (404, { "Tipul de conținut": "aplicație/json" });
res.Sfârşit(JSON.stringe({ mesaj: eroare }));
 }
}

Acest bloc de cod extrage fișierul id de la url, șterge documentul cu potrivirea id, trimite codul de stare și anteturile și închide cererea.

În sfârșit, import router în dumneavoastră server.js dosar și sună la dvs router functie, trecere solicitat și res ca argumente:

const router = cere(""./routes/blogRoutes");
const server = http.createServer((req, res) => {
 router (req, res);
});

Acest lucru permite serverului dvs. să intercepteze și să gestioneze cererile în mod corespunzător.

Puteți găsi proiectul finalizat în aceasta Depozitul GitHub.

Folosind un cadru Node.js

Chiar dacă este posibil să creați manual un API web, poate fi o sarcină dificilă. Va trebui să vă asigurați că ați acoperit o mulțime de cazuri marginale și că codul dvs. ar fi bine să fie fără erori.

De-a lungul anilor, dezvoltatorii au construit cadre precum ExpressJS, NestJS, Fastify etc., pentru a face mult mai ușor.