Hur man bygger ett GraphQL API med Apollo Server och MongoDB

En av de mest avgörande faktorerna att tänka på när man designar en applikation är vilken typ av API-arkitektur som ska användas. Effektiv API-design är avgörande för att säkerställa att appar fungerar under hela sin livscykel.

RESTful arkitektur är det mest populära tillvägagångssättet, men det har en betydande nackdel: en fast slutpunktsstruktur som returnerar förutbestämda data. Denna design kan resultera i ineffektiv kommunikation.

Däremot erbjuder GraphQL – ett alternativ till REST – mer flexibilitet genom att du bara kan begära den data du behöver.

Vad är GraphQL API: er?

GraphQL är ett frågespråk som du kan använda för att skriva backend-API: er (Application Programming Interfaces). Till skillnad från REST API: er, som har flera slutpunkter för olika data, har GraphQL API: er bara en ingångspunkt.

Klienter kan specificera den data de behöver i sina frågor från denna enda ingångspunkt, vilket gör det mer flexibelt och effektivt för att bara hämta nödvändig data.

Enkelt uttryckt implementerar ett GraphQL API den GraphQL-arkitektur som beskrivs av GraphQL-specifikationer. Denna design innebär att definiera schemat, frågorna och mutationerna som klienter kan interagera med.

Här är en förenklad uppdelning av de väsentliga komponenterna i GraphQL API-arkitekturen:

1. Schema: Ett schema är en beskrivning av de typer av data och operationer som API tillhandahåller. I grund och botten definierar ett schema strukturen för tillgänglig data och vilken typ av frågor och mutationer som en klient kan utföra för att modifiera data.
2. Frågor: Klienter använder frågor för att hämta data från databasen genom att specificera strukturen för de data de behöver. Dessutom kan de kapsla flera frågor i en enda HTTP-förfrågan för att hämta relaterade data från flera slutpunkter.
3. Mutationer: Mutationer är operationer som används för att modifiera data i databasen. Klienter kan skicka mutationsförfrågningar för att skapa, uppdatera eller ta bort data.

Konfigurera en MongoDB-databas

För att starta, skapa en MongoDB-databas. Alternativt kan du ställ in ett MongoDB-kluster i molnet gratis.När du har konfigurerat din databas, kopiera MongoDB: s databasanslutning URI-sträng.

Du kan hitta detta projekts kod i dess GitHub-förråd.

Skapa en Apollo-server

Apollo server är en populär GraphQL-serverimplementering som låter dig bygga GraphQL API: er i JavaScript-miljöer, inklusive Node.js, Express och mer.

Skapa en katalog för ett nytt projekt och CD Gillar det:

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

Initiera sedan ett nytt Node.js-projekt.

npm init --ja

Detta kommando skapar en package.json fil.

Installera nödvändiga beroenden

Kör följande kommando för att installera paketen.

npm installera apollo-server graphql mongoose

Slutligen, skapa en index.js filen i ditt projekts rotkatalog.

Konfigurera Apollo-servern

Öppen index.js och lägg till koden nedan:

konst { ApolloServer } = behöva('apollo-server');
konst mangust = behöva('mungo');
konst typeDefs = behöva("./graphql/typeDefs");
konst lösare = behöva("./graphql/resolvers");
konst server = ny ApolloServer({
 typDefs, 
 lösare 
});
konst MONGO_URI = 'mongodb://localhost: 27017';
mungo
 .connect (MONGO_URI, {
 useNewUrlParser: Sann,
 använd UnifiedTopology: Sann,
 })
 .sedan(() => {
trösta.logga(`Db ansluten`);
lämna tillbaka server.listen({ hamn: 5000 });
 })
 .sedan((res) => {
trösta.logga(`Server körs kl ${res.url}`);
 })
 .fånga(fela => {
trösta.log (err.meddelande);
 });

Denna kod initierar en lokal GraphQL-server med hjälp av Apollo Server-biblioteket. Den upprättar sedan en anslutning till en MongoDB-databas med den givna anslutnings-URI.

Lägg märke till hur koden skickar två argument till den nya instansen av ApolloServer: typeDefs och resolvers. Dessa anger datatyperna och de operationer som GraphQL API kan utföra.

Efter att anslutningen till MongoDB-databasen har ställts in börjar servern lyssna på port 5000.

Definiera datamodellen

Skapa en ny mapp i rotkatalogen i din projektmapp och namnge den modeller. Skapa nya filnamn i den här mappen dataModel.js och lägg till följande kod:

konst {modell, Schema} = behöva('mungo');
konst anställd Schema = ny Schema({
 namn: Sträng,
 avdelning: Sträng,
 lön: Sträng,
});
modul.exports = modell('Anställd', anställd Schema);

Definiera GraphQL-schemat

Ett GraphQL-schema definierar strukturen för de data som du kan fråga med hjälp av GraphQL API. Schemat beskriver också de frågor och mutationer som API: et kan köra. Du kan använda frågor för att hämta data och mutationer för att ändra dem.

Skapa en ny mapp i rotkatalogen för ditt projekt och namnge den graphql. Lägg till två filer i den här mappen: typeDefs.js och resolvers.js

Lägg till koden nedan i filen typeDefs.js:

konst {gql} = behöva("apollo-server");
konst typeDefs = gql`
 typ anställd {
 jag gjorde!
 namn: Sträng
 avdelning: Sträng
 lön: Sträng
 }
 input EmployeeInput {
 namn: Sträng
 avdelning: Sträng
 lön: Sträng
 }
 typ Fråga { 
 getEmployee (id: ID): Anställd #lämna tillbaka Anställd efter id
 anställda: [Anställd] #lämna tillbaka array av Anställda
 }
 typ mutation {
 createEmployee (employeeInput: EmployeeInput): Anställd
 uppdatera Employee (id: ID, anställdInput: EmployeeInput): Boolean
 deleteEmployee (id: ID): Boolean
 }
`;
modul.exports = typeDefs;

Den här koden ovan använder gql funktion som tillhandahålls av apollo-serverpaketet för att skapa ett GraphQL-schema för anställds data.

Schemat består av fyra huvudelement: datatyper för anställd information, indatatyper, frågor och mutationer som API: et kan utföra.

Definiera resolvers för GraphQL API

En resolver är en GraphQL-funktion som definierar data som ska skickas vidare när en klient skickar en API-fråga för att hämta data. I huvudsak är dess primära roll att hämta de nödvändiga data från den angivna datakällan och returnera den till klienten.

Lägg till koden nedan till resolvers.js fil i graphql mapp. Upplösarna, i det här fallet, specificeras i Query- och Mutationsobjekten.

Query-objektet definierar två metoder: anställda och skaffa anställd. Dessa metoder är ansvariga för att hämta personaldata från databasen på begäran av en kund.

konst Anställd= behöva("../models/employeesModel");
// GraphQL Resolvers
konst resolvers = {
 Fråga: {
 anställda: asynkron () => {
Prova {
konst anställda = vänta Employee.find({});
lämna tillbaka anställda;
 } fånga (fel) {
trösta.error (fel);
kastanyFel("Det gick inte att hämta anställda");
 }
 },
 getEmployee: asynkron (förälder, args) => {
Prova {
konst anställd = vänta Employee.findById (args.id);
lämna tillbaka anställd;
 } fånga (fel) {
trösta.error (fel);
kastanyFel("Det gick inte att hämta anställd med ID");
 }
 },
 },

Mutationsobjektet har tre metoder: skapa medarbetare, uppdatera Anställd, och radera anställd. Dessa metoder gör ändringar i data som lagras i MongoDB-databasen.

 Mutation: {
asynkron skapa Employee (_, { anställdInput: { namn, avdelning, lön } }) {
konst ny anställd = ny Anställd({
 namn: namn,
 avdelning: avdelning,
 lön: lön
 });
konst svar = vänta newEmployee.save();
trösta.log (ny anställd);
lämna tillbaka {
 id: response._id,
 ...svar._doc
 }
 },
asynkron uppdatera Employee (_, {id, anställdInput: {namn, avdelning, lön}}) {
konst uppdaterad Anställd = vänta Employee.updateOne(
 { _id: id },
 { namn, avdelning, lön }
 );
om (!updatedEmployee) {
kastanyFel(`Anställd med ID: ${id} inte hittat`);
 }
lämna tillbakaSann; // Returnera ett booleskt värde som indikerar att uppdateringen lyckats
 },
asynkron deleteEmployee (_, {id}) {
konst raderadAnställd = vänta Employee.deleteOne({ _id: id });

om (!deletedEmployee || deletedEmployee.deletedCount 0) {
kastanyFel(`Anställd med ID ${id} inte hittat`);
 }
lämna tillbakaSann; // Returnera ett booleskt värde som indikerar borttagningen
 },
 },
};
modul.exports = resolvers;

Kör slutligen det här kommandot för att snurra upp servern:

nod index.js

När den har upprättat en databasanslutning kommer servern att starta på port 5000.

Du kan gå vidare och testa funktionaliteten hos GraphQL API genom att göra HTTP-förfrågningar från GraphQL-lekplatsen i din webbläsare.

Du kan till exempel använda skapa medarbetare mutation för att lägga till nya anställdas data i MongoDB-databasen.

GraphQL-popularitet i utvecklargemenskapen

GraphQL vinner dragkraft i utvecklargemenskapen som en alternativ API-designstrategi till den populära REST-arkitekturen.

Detta beror på dess förmåga att tillhandahålla ett mer flexibelt och effektivt sätt att hämta data från olika källor, allt från en enda ingångspunkt. Detta undviker att behöva hantera flera slutpunkter för olika data, vilket är ett vanligt problem med REST API-arkitektur. Denna designlösning effektiviserar processen att bygga och hantera backend-API: er.