Kako stvoriti NodeJS API bez korištenja okvira

Kako stvoriti NodeJS API bez korištenja okvira

Node.js je open-source JavaScript runtime izgrađen na chromeovom v8 motoru koji vam omogućuje pokretanje JavaScript koda izvan preglednika.





Njegov model događaja, ekosustav i brzina učinili su Node.js jednim od najtraženijih i najkorištenijih runtimea za aplikacije na strani poslužitelja.



Većina Node.js API poslužitelja koristi Express ili neki drugi okvir. Međutim, također možete stvoriti jednostavan Node.js API bez okvira u samo nekoliko koraka.





MAKEUSEOF VIDEO DANA

Korak 1: Postavljanje vašeg razvojnog okruženja

Napravite imenik projekta i CD u njega tako što ćete pokrenuti:

mkdir nodejs-api 
cd nodejs-api

Zatim inicijalizirajte npm u vašem projektu pokretanjem:



npm init -y

Ovaj CRUD API će sadržavati korištenje MongoDB-a, NoSQL baze podataka i njenog popularnog ODM-a, mongoose.

Pokrenite sljedeću naredbu za instalaciju mungos :



npm install mongoose

Zatim stvorite a server.js datoteku u korijenskom direktoriju vašeg projekta i dodajte blok koda u nastavku za stvaranje poslužitelja:

const http = require("http"); 
const server = http.createServer((req, res) => {}); 
  
server.listen(3000, () => { 
  console.log(`Server is running`); 
});

Ovaj blok koda uvozi http modul, temeljni modul Node.js. http modul omogućuje Node.js prijenos podataka preko HTTP-a. Ovaj modul sadrži metode potrebne za kreiranje poslužitelja.



Zatim poziva http module createServer metoda koja stvara i vraća instancu poslužitelja. The createServer metoda uzima funkciju povratnog poziva s objektom zahtjeva i odgovora kao parametrima.

Zatim, kod poziva slušati metoda na vraćenoj instanci poslužitelja. To omogućuje poslužitelju da počne osluškivati ​​promet na danom priključku. The slušati metoda aktivira povratni poziv—drugi argument—kada uspije.

Na kraju, stvorite dva direktorija pod nazivom rute i modeli u korijenskom direktoriju vašeg projekta. The rute sadržavat će logiku usmjeravanja za vaš API, dok model će sadržavati sve što se odnosi na bazu podataka.

Korak 2: Povezivanje vaše aplikacije s bazom podataka

U server.js , uvoz mungos :

const mongoose = require("mongoose");

Nazovite Spojiti metoda na mungos i proslijedite svoj MongoDB URI kao argument:

mongoose.connect("MongoDB_URI")

Korak 3: Stvaranje API modela

Napravite CRUD API za jednostavnu blog aplikaciju. U vašem modeli mapu, stvorite a blogModel.js datoteku i dodajte sljedeći kod u svoju datoteku:

const mongoose = require("mongoose"); 
const blogSchema = mongoose.Schema({ 
  title: { 
    type: String, 
    required: [true, "Blog must have a title"], 
  }, 
  body: { 
    type: String, 
    required: [true, "Blog must have a body"], 
  }, 
}); 
module.exports = mongoose.model("Blog", blogSchema);

Gornji blok koda stvara mongoose model s dva svojstva i preslikava ih u MongoDB bazu podataka.

kako isključiti monitor prijenosnog računala

Oba svojstva u ovom modelu imaju a Niz tip sa potreban postavljen pravi . Popratne poruke pogreške prikazat će se ako tijelo zahtjeva ne sadrži nijedno od svojstava.

Posljednji redak stvara i izvozi mungosov model pozivanjem model metoda na mungos. Proslijedite naziv modela ( Blog ) kao prvi argument i shema ( blogSchedule ) kao drugi argument.

Korak 4: Implementacija usmjeravanja u vašoj aplikaciji

Bez pomoći okviri poput Expressa , morat ćete ručno stvoriti logiku za obradu svakog zahtjeva upućenog vašem API-ju.

Najprije stvorite a blogRoutes.js datoteku u vašem rute mapu, zatim uvezite model bloga:

const Blog = require("../models/blogModel");

Zatim stvorite asinkroni ruter funkcija, prolaz zahtijevati i res kao parametre i izvezite funkciju:

const router = async function (req, res) {}; 
module.exports = router;

Ova funkcija će sadržavati svu vašu logiku usmjeravanja.

Zatim ćete implementirati logiku usmjeravanja rutu po rutu.

GET Rute

Dodajte blok koda u nastavku u svoj ruter funkcija za implementaciju DOBITI rukovatelj rute za zahtjeve upućene /api/blogovi :

//  GET: /api/blogs 
if (req.url === "/api/blogs" && req.method === "GET") { 
    // get all blogs 
    const blogs = await Blog.find(); 
  
    // set the status code and content-type 
    res.writeHead(200, { "Content-Type": "application/json" }); 
  
    // send data 
    res.end(JSON.stringify(blogs)); 
}

Gornji blok koda provjerava url i metoda svojstva objekta zahtjeva. Zatim dohvaća sve blogove iz baze podataka putem pronaći metoda na mungosovom modelu ( Blog ).

Zatim, poziva writeHead metoda na res , objekt odgovora. Ova metoda šalje zaglavlje odgovora s tri argumenta: šifrom statusa, opcijskom porukom o statusu i zaglavljima. The 200 statusni kod predstavlja uspješan odgovor, a tip sadržaja za ovaj API poziv postavljen je na aplikacija/json .

Na kraju, zatvorite zahtjev kako biste bili sigurni da poslužitelj ne visi pozivom kraj metoda na res . Poziv na JSON.stringify pretvara blogovi objekt na JSON niz i prosljeđivanje toga u kraj metoda ga vraća kao tijelo odgovora.

Dodajte blok koda u nastavku u svoj ruter funkcija za implementaciju DOBITI rukovatelj rutom za jedan resurs:

// GET: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "GET") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
  
        // get blog from DB 
        const blog = await Blog.findById(id); 
  
        if (blog) { 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        } else { 
            throw new Error("Blog does not exist"); 
        } 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: error })); 
    } 
}

Ovaj kod koristi odgovarati metoda, koja uzima regex izraz kao argument, kako bi provjerila odgovara li url formatu: /api/blogs/ .

Zatim izvucite iskaznica imovine iz url niz pozivanjem njegovog podjela metoda. Ova metoda uzima uzorak kao argument ( / ), dijeli niz na temelju uzorka i vraća niz. Treći element tog niza je iskaznica .

Na kraju, dohvatite dokument s podudaranjem iskaznica iz vaše baze podataka. Ako postoji, pošaljite a kod odgovora 200 , zatvorite zahtjev i pošaljite dohvaćeni blog. Ako ne postoji, javite pogrešku i pošaljite je kao odgovor u catch bloku.

POST ruta

Dodajte blok koda u nastavku funkciji usmjerivača kako biste implementirali POST rukovatelj rutom:

// POST: /api/blogs/ 
if (req.url === "/api/blogs" && req.method === "POST") { 
    try { 
        let body = ""; 
  
        // Listen for data event 
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
  
        // Listen for end event 
        req.on("end", async () => { 
            // Create Blog 
            let blog = new Blog(JSON.parse(body)); 
  
            // Save to DB 
            await blog.save(); 
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(blog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

Objekt zahtjeva implementira Node.js ReadableStream sučelje. Ovaj potok emitira a podaci i an kraj događaj koji vam daje pristup podacima iz tijela zahtjeva.

Ovaj kod osluškuje podatkovni događaj i rukuje njime pretvarajući ga u niz i ulančavajući ga u tijelo varijabla. u kraj rukovatelj događajima, stvara a Blog instanca s raščlanjenim nizom tijela. Zatim sprema novi blog, šalje statusni kod i zaglavlje sadržaja i zatvara zahtjev.

PUT Ruta

Dodajte blok koda u nastavku funkciji usmjerivača kako biste implementirali STAVITI rukovatelj rutom:

// PUT: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "PUT") { 
    try { 
        // extract id from url 
        const id = req.url.split("/")[3]; 
        let body = ""; 
  
        req.on("data", (chunk) => { 
            body += chunk.toString(); 
        }); 
        req.on("end", async () => { 
            // Find and update document 
            let updatedBlog = await Blog.findByIdAndUpdate(id, JSON.parse(body), { 
                new: true, 
            }); 
  
            res.writeHead(200, { "Content-Type": "application/json" }); 
            res.end(JSON.stringify(updatedBlog)); 
        }); 
    } catch (error) { 
        console.log(error); 
    } 
}

Rukovatelj PUT zahtjevima gotovo je identičan POST rukovatelj zahtjevima, osim što izdvaja iskaznica imovine iz url za ažuriranje relevantnog bloga.

IZBRIŠI rutu

Dodajte blok koda u nastavku funkciji usmjerivača kako biste implementirali svoju IZBRISATI rukovatelj rutom:

// DELETE: /api/blogs/:id 
if (req.url.match(/\/api\/blogs\/([0-9]+)/) && req.method === "DELETE") { 
    try { 
        const id = req.url.split("/")[3]; 
         
       // Delete blog from DB 
        await Blog.findByIdAndDelete(id); 
        res.writeHead(200, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: "Blog deleted successfully" })); 
    } catch (error) { 
        res.writeHead(404, { "Content-Type": "application/json" }); 
        res.end(JSON.stringify({ message: error })); 
    } 
}

Ovaj blok koda izdvaja iskaznica od url , briše dokument s odgovarajućim iskaznica , šalje statusni kod i zaglavlja i zatvara zahtjev.

Na kraju, uvoz ruter u vašem server.js datoteku i nazovite svoju ruter funkcija, prolaznost zahtijevati i res kao argumenti:

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

To omogućuje vašem poslužitelju presretanje i obradu zahtjeva na odgovarajući način.

Dovršeni projekt možete pronaći ovdje GitHub spremište .

Korištenje okvira Node.js

Iako je moguće izraditi web API ručno, to može biti težak zadatak. Morat ćete provjeriti jeste li pokrili mnogo rubnih slučajeva i bolje bi bilo da vaš kod bude bez grešaka.

Tijekom godina programeri su izgradili okvire kao što su ExpressJS, NestJS, Fastify itd. kako bi to učinili mnogo lakšim.