GraphQL oferă o alternativă flexibilă la abordarea clasică REST atunci când construiți un API.

Unul dintre cei mai importanți factori de luat în considerare atunci când proiectați o aplicație este tipul de arhitectură API de utilizat. Designul eficient al API-ului este esențial pentru a ne asigura că aplicațiile sunt performante pe tot parcursul ciclului lor de viață.

Arhitectura RESTful este cea mai populară abordare, dar are un dezavantaj semnificativ: o structură fixă ​​a punctului final care returnează date predeterminate. Acest design poate duce la o comunicare ineficientă.

În schimb, GraphQL — o alternativă la REST — oferă mai multă flexibilitate, permițându-vă să solicitați doar datele de care aveți nevoie.

Ce sunt API-urile GraphQL?

GraphQL este un limbaj de interogare pe care îl puteți folosi pentru a scrie API-uri backend (Interfețe de programare a aplicațiilor). Spre deosebire de API-urile REST, care au mai multe puncte finale pentru date diferite, API-urile GraphQL au un singur punct de intrare.

instagram viewer

Clienții pot specifica datele de care au nevoie în interogările lor din acest punct de intrare unic, făcându-l mai flexibil și mai eficient pentru preluarea doar a datelor necesare.

Mai simplu spus, un API GraphQL implementează arhitectura GraphQL descrisă de Specificațiile GraphQL. Acest design implică definirea schemei, interogărilor și mutațiilor cu care clienții pot interacționa.

Iată o defalcare simplificată a componentelor esențiale ale arhitecturii GraphQL API:

  1. Schemă: o schemă este o descriere a tipurilor de date și operațiuni pe care API-ul le oferă. Practic, o schemă definește structura datelor disponibile și tipul de interogări și mutații pe care un client le poate executa pentru a modifica datele.
  2. Interogări: Clienții folosesc interogări pentru a prelua date din baza de date specificând structura datelor de care au nevoie. Mai mult, ei pot imbrica mai multe interogări într-o singură solicitare HTTP pentru a prelua date aferente de la mai multe puncte finale.
  3. Mutații: Mutațiile sunt operațiuni utilizate pentru modificarea datelor din baza de date. Clienții pot trimite cereri de mutație pentru a crea, actualiza sau șterge date.

Configurați o bază de date MongoDB

Pentru a incepe, creați o bază de date MongoDB. Alternativ, puteți configurați gratuit un cluster MongoDB în cloud.Odată ce ați configurat baza de date, copiați șirul URI de conexiune la baza de date MongoDB.

Puteți găsi codul acestui proiect în documentul său Depozitul GitHub.

Creați un server Apollo

Apollo Server este o implementare populară de server GraphQL care vă va permite să construiți API-uri GraphQL în medii JavaScript, inclusiv Node.js, Express și multe altele.

Creați un director pentru un nou proiect și CD în ea:

mkdir graphql-API-mongoDB
cd graphql-API-mongoDB

Apoi, inițializați un nou proiect Node.js.

npm init --da

Această comandă creează un pachet.json fişier.

Instalați dependențele necesare

Rulați următoarea comandă pentru a instala pachetele.

npm instalează apollo-server graphql mongoose

În cele din urmă, creați un index.js fișier în directorul rădăcină al proiectului dvs.

Configurați serverul Apollo

Deschis index.js si adauga codul de mai jos:

const { ApolloServer } = cere("Apollo-server");
const mangusta = cere('mangustă');
const typeDefs = cere(„./graphql/typeDefs”);
const rezolutori = cere(„./graphql/resolvers”);
const server = nou ApolloServer({
 tipDefs, 
 rezolutori 
});


const MONGO_URI = „mongodb://localhost: 27017”;
mangustă
 .connect (MONGO_URI, {
 useNewUrlParser: Adevărat,
 useUnifiedTopology: Adevărat,
 })
 .apoi(() => {
consolă.Buturuga(`Db Connected`);
întoarcere server.listen({ port: 5000 });
 })
 .apoi((res) => {
consolă.Buturuga(`Serverul rulează la ${res.url}`);
 })
 .captură(a greșit => {
consolă.log (err.message);
 });

Acest cod inițializează un server local GraphQL folosind biblioteca Apollo Server. Apoi stabilește o conexiune la o bază de date MongoDB cu URI-ul de conectare dat.

Observați cum codul transmite două argumente noii instanțe a ApolloServer: typeDefs și resolvers. Acestea specifică tipurile de date și operațiunile pe care API-ul GraphQL le poate executa.

După ce conexiunea la baza de date MongoDB este configurată, serverul începe să asculte pe portul 5000.

Definiți modelul de date

Creați un folder nou în directorul rădăcină al folderului proiectului și denumiți-l modele. În acest folder, creați un nou nume de fișier dataModel.js și adăugați următorul cod la el:

const {model, Schema} = cere('mangustă');
const employeeSchema = nou Schemă({
 Nume: Şir,
 departament: Şir,
 salariu: Şir,
});
modul.exports = model('Angajat', Schema angajat);

Definiți schema GraphQL

O schemă GraphQL definește structura datelor pe care le puteți interoga folosind API-ul GraphQL. Schema subliniază, de asemenea, interogările și mutațiile pe care API-ul le poate rula. Puteți folosi interogări pentru a prelua date și mutații pentru a le modifica.

În directorul rădăcină al proiectului, creați un folder nou și denumiți-l graphql. În acest folder, adăugați două fișiere: typeDefs.js și resolvers.js

Adăugați codul de mai jos în fișierul typeDefs.js:

const {gql} = cere("apollo-server");
const typeDefs = gql`
 tip angajat {
 am facut!
 Nume: Şir
 departament: Şir
 salariu: Şir
 }
 intrare EmployeeInput {
 Nume: Şir
 departament: Şir
 salariu: Şir
 }
 tip Query { 
 getEmployee (id: ID): # de angajatîntoarcere Angajat după id
 angajați: [Angajat] #întoarcere matrice de Angajatii
 }
 tip mutație {
 createEmployee (employeeInput: EmployeeInput): Angajat
 updateEmployee (ID: ID, angajatInput: EmployeeInput): boolean
 deleteEmployee (cod: ID): boolean
 }
`;
modul.exports = typeDefs;

Acest cod de mai sus folosește gql funcție furnizată de pachetul apollo-server pentru a crea o schemă GraphQL pentru datele angajaților.

Schema constă din patru elemente principale: tipuri de date pentru informații despre angajați, tipuri de intrare, interogări și mutații pe care API-ul le poate efectua.

Definiți rezolutorii pentru API-ul GraphQL

Un resolver este o funcție GraphQL care definește datele care trebuie transmise atunci când un client trimite o interogare API pentru a prelua date. În esență, rolul său principal este de a prelua datele necesare din sursa de date specificată și de a le returna clientului.

Adăugați codul de mai jos la resolvers.js dosar în graphql pliant. Resolverii, în acest caz, sunt specificați în obiectele Query și Mutation.

Obiectul Query definește două metode: angajati și getEmployee. Aceste metode sunt responsabile pentru preluarea datelor angajaților din baza de date la cererea unui client.

const Angajat= cere(„../models/employeesModel”);
// Rezolvatori GraphQL
const rezolutori = {
 Interogare: {
 angajati: asincron () => {
încerca {
const angajati = așteaptă Employee.find({});
întoarcere angajati;
 } captură (eroare) {
consolă.eroare (eroare);
aruncanouEroare(„Nu s-au putut prelua angajații”);
 }
 },
 getEmployee: asincron (părinte, argumente) => {
încerca {
const angajat = așteaptă Employee.findById (args.id);
întoarcere angajat;
 } captură (eroare) {
consolă.eroare (eroare);
aruncanouEroare(„Nu s-a putut prelua angajatul după ID”);
 }
 },
 },

Obiectul Mutation are trei metode: createEmployee, updateAngajat, și deleteEmployee. Aceste metode fac modificări datelor stocate în baza de date MongoDB.

 Mutație: {
asincron createEmployee (_, { angajatInput: { nume, departament, salariu } }) {
const nouAngajat = nou Angajat({
 nume: nume,
 departament: departament,
 salariu: salariu
 });
const răspuns = așteaptă newEmployee.save();
consolă.log (Angajat nou);


întoarcere {
 id: răspuns._id,
 ...răspuns._doc
 }
 },


asincron updateEmployee (_, {id, angajatInput: {nume, departament, salariu}}) {
const updatedEmployee = așteaptă Employee.updateOne(
 { _id: id },
 { nume, departament, salariu }
 );


dacă (!Angajat actualizat) {
aruncanouEroare(`Angajat cu act de identitate: ${id} negăsit`);
 }


întoarcereAdevărat; // Returnează o valoare booleană care indică succesul actualizării
 },


asincron deleteEmployee (_, {id}) {
const deletedEmployee = așteaptă Employee.deleteOne({ _id: id });

dacă (!deletedEmployee || deletedEmployee.deletedCount 0) {
aruncanouEroare(`Angajat cu act de identitate ${id} negăsit`);
 }


întoarcereAdevărat; // Returnează o valoare booleană care indică succesul ștergerii
 },
 },
};
modul.exports = rezolutori;

În cele din urmă, rulați această comandă pentru a porni serverul:

nod index.js

Odată ce a stabilit o conexiune la baza de date, serverul va porni pe portul 5000.

Puteți continua și testa funcționalitatea API-ului GraphQL făcând solicitări HTTP din terenul de joacă GraphQL din browser.

De exemplu, puteți utiliza createEmployee mutație pentru a adăuga date noi angajaților în baza de date MongoDB.

Popularitatea GraphQL în comunitatea dezvoltatorilor

GraphQL câștigă acțiune în comunitatea dezvoltatorilor ca o abordare alternativă de design API la arhitectura populară REST.

Acest lucru se datorează capacității sale de a oferi o modalitate mai flexibilă și mai eficientă de a prelua date din diverse surse, toate dintr-un singur punct de intrare. Acest lucru evită gestionarea mai multor puncte finale pentru date diferite, ceea ce este o problemă comună cu arhitectura API REST. Această soluție de proiectare simplifică procesul de construire și gestionare a API-urilor backend.