Introduksjon til å lage GraphQL APIer og apper i Node.JS

Kommunikasjon og dataoverføring mellom frontend og backend av ethvert applikasjon skjer gjennom APIer (applikasjonsprogrammeringsgrensesnitt). Det er mange forskjellige typer APIer som brukes til å kommunisere mellom front- og back-end applikasjoner som RESTful API, SOAP API, GraphQL API, etc. GraphQL API er en relativt ny teknologi, og den er mye raskere enn andre typer APIer tilgjengelig. Å hente data fra databasen ved hjelp av GraphQL API er mye raskere enn REST API. Mens han bruker GraphQL API, har klienten kontroll for å hente bare de nødvendige dataene i stedet for å få alle detaljene; Det er grunnen til at GraphQL API fungerer raskere enn REST API.

Installere pakker

Vi skal bygge en node.JS -applikasjon ved hjelp av GraphQL API, så vi må installere node.JS og NPM for dette før du starter prosjektet.

ubuntu@ubuntu: ~ $ sudo apt -get update -y
ubuntu@ubuntu: ~ $ sudo apt-get install nodejs
ubuntu@ubuntu: ~ $ sudo apt-get install npm

Sette opp prosjekt

Vi vil bruke rammen 'Express' fra Node.JS for å bygge vår søknad. Lag en katalog som heter 'Graphql' og initier prosjektet.

ubuntu@ubuntu: ~ $ mkdir grafql
ubuntu@ubuntu: ~ $ cd grafql/
ubuntu@ubuntu: ~ $ npm init -y

MongoDB -oppsett

I vårt GraphQL -prosjekt vil vi bruke MongoDB som vår database. MongoDB er en skjemalessedatabase og lagrer data i form av nøkkelpar. Følg de gitte trinnene for å installere MongoDB.

Importer den offentlige GPG -nøkkelen for MongoDB.

ubuntu@ubuntu: ~ $ wget -qo - https: // www.Mongodb.org/statisk/pgp/server-4.4.ASC | sudo apt-key add -

Opprett listefilen for MongoDB.

ubuntu@ubuntu: ~ $ ekko "Deb [arch = amd64, arm64] https: // repo.Mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse "| sudo tee/etc/apt/kilder.liste.d/mongodb-org-4.4.liste

Oppdater lokale depoter.

ubuntu@ubuntu: ~ $ sudo apt -get update -y

Installer MongoDB -pakken.

ubuntu@ubuntu: ~ $ sudo apt-get install -y mongodb-org

Start og aktiver Mongod.service.

ubuntu@ubuntu: ~ $ sudo systemctl start mongod.service
ubuntu@ubuntu: ~ $ sudo systemctl enable mongod.service

Installere NPM -moduler

For GraphQL -applikasjonen vår, må vi installere noen NPM -pakker. Vi vil installere Cors, Express, Body-Parser, Mongoose, etc.

ubuntu@ubuntu: ~ $ cd grafql/
ubuntu@ubuntu: ~ $ npm install cors express body-parser mongoose-sparer

For å lage en GraphQL API, må vi installere en ekstra NPM-pakke som heter 'Apollo-Server-Express.'Denne npm -pakken brukes til å kjøre GraphQL -server med all node.JS HTTP -rammer som 'Express.'

ubuntu@ubuntu: ~ $ npm installer apollo-server-express--LAVE

Definere MongoDB -skjema

Nå har vi miljøet vårt satt opp for GraphQL -applikasjonen vår i Node.JS, og det er på tide å definere et skjema for søknaden vår. Lag en fil 'modeller/student.JS 'i prosjektrotkatalogen.

// Definere studentskjema
const mongoose = krever ('mongoose');
const studentschema = ny mongoose.Skjema (
Navn:
Type: Streng,
Påkrevd: sant
,
Klasse:
Type: Nummer,
Påkrevd: sant
,
Major:
Type: Streng,
Påkrevd: sant

,
Tidsstempler: True
);
const student = mongoose.Model ('Student', Studentschema);
modul.Eksport = Student, Studentschema

I det ovennevnte skjemaet må hver elev ha et navn, klasse og major.

Bygg grafql API

Etter å ha opprettet studentskjemaet, vil vi nå bygge GraphQL API. Lag et "skjema.JS 'for å skrive grafql -parametere. Det er to parametere, 'typer' og 'oppløsere', brukt i GraphQL API. I 'typer' vil vi spesifisere skjemaet vårt, spørsmålene (e.g., Komme med forespørsler), og mutasjoner (e.g., Lage oppdatering eller slette forespørsler) til det spesifiserte skjemaet. Vi vil skrive de forskjellige metodene som er definert i 'typer' for å koble spørsmålene og mutasjonene med databasen i 'Resolvere.'

// Importere skjema og modul
const gql = krever ('apollo-server-express');
const student = krever ('./modeller/student ').Student;
// Definere skjema, spørring og mutasjonstype
const typedefs = gql '
type student
jeg gjorde!,
Navn: Streng!,
Klasse: Int!,
Major: String!

type spørring
GetStudents: [Student],
GetStudentById (ID: ID!): Student

type mutasjon
AddStudent (navn: streng!, Klasse: Int!, Major: String! ): Student
updatestudent (navn: streng!, Klasse: Int!, Major: String! ): Student
Deletestudent (ID: ID! ): Student
'
// Definere oppløsere
const oppløsere =
Spørring:
getStudents: (foreldre, args) =>
Returner student.finne();
,
getStudentById: (foreldre, args) =>
Returner student.FindbyId (Args.id);

,
Mutasjon:
addStudent: (foreldre, args) =>
La student = ny student (
Navn: Args.Navn,
Klasse: Args.klasse,
Major: Args.major
);
Returner student.lagre();
,
updatestudent: (foreldre, args) =>
hvis(!Args.id) retur;
Returner student.findOneAndUpdate (
_id: Args.id
,

$ sett:
Navn: Args.Navn,
Klasse: Args.klasse,
Major: Args.major

,
Ny: True, (feil, student) =>
if (feil)
konsoll.logg (feil);
annet ;
)



modul.eksport =
typedefs,
oppløsere

Opprette GraphQL API -server

Nå er vi nesten ferdige med å lage GraphQL -applikasjonen. Det eneste trinnet som er igjen er å opprette serveren. Lag en fil som heter 'App.JS 'for å konfigurere serverparametere.

// Importere nødvendige pakker
const express = krever ('ekspress');
const mongoose = krever ('mongoose');
const BodyParser = krever ('Body-Parser');
const cors = krever ('cors');
const apolloServer = krever ('apollo-server-express');
// Importere skjema
const typedefs, oppløsere = krever ('./skjema ');
// Koble til MongoDB
const url = “Mongodb: // 127.0.0.1: 27017/studenter ”;
const connect = mongoose.Connect (URL, uSenewurlParser: true);
koble.da ((db) =>
konsoll.logg ('tilkobling vellykket');
, (feil) =>
konsoll.logg (feil);
);
// Opprette server
const server = new ApolloServer (
Typedefs: Typedefs,
Oppløsere: Oppløsere
);
const app = express ();
app.Bruk (BodyParser.json ());
app.bruk ('*', Cors ());
server.ApplyMiddleware (app);
app.Lytt (8000, () =>

konsoll.logg ('lytte til 8000');
)

Testing av GraphQL API

Vi har GraphQL -serveren vår i gang på port 8000, og det er på tide å teste GraphQL API. Åpne grafql -websiden i nettleseren ved å besøke følgende URL.

http: // localhost: 8000/graphql

Og det vil åpne følgende webside.

Legg studenten i databasen ved hjelp av GraphQL API.

På samme måte kan du legge til flere studenter, og etter å ha lagt til studenten, få alle studentene som bruker GraphQL API.

Legg merke til IDen til noen av studentene og få den spesifikke studenten til å bruke IDen.

Konklusjon

Å hente data fra databasen ved hjelp av Standard REST API gjør spørringen treg, ettersom vi noen ganger får mer data enn nødvendig. Ved hjelp av GraphQL kan vi hente nøyaktig de nødvendige dataene som gjør GraphQL API raskere. I dette demoprosjektet har vi bare et enkelt skjema, så vi har laget GraphQL API for det enkeltskjemaet. Vi har også definert tre til fire metoder for skjemaet. Du kan opprette mer enn én spørring eller mutasjoner i henhold til applikasjonen din.