Sådan bygger du en GraphQL API med Apollo Server og MongoDB

En af de mest afgørende faktorer at overveje, når man designer en applikation, er typen af ​​API-arkitektur, der skal bruges. Effektivt API-design er afgørende for at sikre, at apps er effektive gennem hele deres livscyklus.

RESTful arkitektur er den mest populære tilgang, men den har én væsentlig ulempe: en fast endepunktsstruktur, der returnerer forudbestemte data. Dette design kan resultere i ineffektiv kommunikation.

I modsætning hertil tilbyder GraphQL - et alternativ til REST - mere fleksibilitet ved kun at lade dig anmode om de data, du har brug for.

Hvad er GraphQL API'er?

GraphQL er et forespørgselssprog, du kan bruge til at skrive backend-API'er (Application Programming Interfaces). I modsætning til REST API'er, som har flere endepunkter for forskellige data, har GraphQL API'er kun ét indgangspunkt.

Kunder kan specificere de data, de har brug for i deres forespørgsler fra dette enkelt indgangspunkt, hvilket gør det mere fleksibelt og effektivt til kun at hente de nødvendige data.

Kort sagt implementerer en GraphQL API GraphQL-arkitekturen beskrevet af GraphQL specifikationer. Dette design involverer at definere skemaet, forespørgsler og mutationer, som klienter kan interagere med.

Her er en forenklet opdeling af de væsentlige komponenter i GraphQL API-arkitekturen:

1. Skema: Et skema er en beskrivelse af de typer data og operationer, som API'en leverer. Grundlæggende definerer et skema strukturen af ​​de tilgængelige data og typen af ​​forespørgsler og mutationer, som en klient kan udføre for at ændre dataene.
2. Forespørgsler: Klienter bruger forespørgsler til at hente data fra databasen ved at specificere strukturen af ​​de data, de har brug for. Desuden kan de indlejre flere forespørgsler i en enkelt HTTP-anmodning for at hente relaterede data fra flere slutpunkter.
3. Mutationer: Mutationer er operationer, der bruges til at ændre data på databasen. Klienter kan sende mutationsanmodninger for at oprette, opdatere eller slette data.

Opsæt en MongoDB-database

For at komme i gang, oprette en MongoDB-database. Alternativt kan du opsætte en MongoDB-klynge i skyen gratis.Når du har sat din database op, kopier MongoDB's databaseforbindelse URI-streng.

Du kan finde dette projekts kode i dens GitHub-depot.

Opret en Apollo-server

Apollo server er en populær GraphQL-serverimplementering, der giver dig mulighed for at bygge GraphQL API'er i JavaScript-miljøer, inklusive Node.js, Express og mere.

Opret en mappe til et nyt projekt og cd ind i det:

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

Derefter skal du initialisere et nyt Node.js-projekt.

npm init --ja

Denne kommando opretter en package.json fil.

Installer de påkrævede afhængigheder

Kør følgende kommando for at installere pakkerne.

npm installer apollo-server graphql mongoose

Til sidst skal du oprette en index.js fil i dit projekts rodbibliotek.

Konfigurer Apollo-serveren

Åben index.js og tilføj koden nedenfor:

konst { ApolloServer } = kræve('apollo-server');
konst mangust = kræve('mangust');
konst typeDefs = kræve("./graphql/typeDefs");
konst resolvere = kræve("./graphql/resolvers");
konst server = ny ApolloServer({
 typeDefs, 
 resolvere 
});
konst MONGO_URI = 'mongodb://localhost: 27017';
mangust
 .connect (MONGO_URI, {
 useNewUrlParser: rigtigt,
 brug UnifiedTopology: rigtigt,
 })
 .derefter(() => {
konsol.log(`Db tilsluttet`);
Vend tilbage server.listen({ Havn: 5000 });
 })
 .derefter((res) => {
konsol.log(`Server kører kl ${res.url}`);
 })
 .fangst(fejl => {
konsol.log (fejl.meddelelse);
 });

Denne kode initialiserer en lokal GraphQL-server ved hjælp af Apollo Server-biblioteket. Den etablerer derefter en forbindelse til en MongoDB-database med den givne forbindelses-URI.

Bemærk, hvordan koden sender to argumenter til den nye instans af ApolloServer: typeDefs og resolvere. Disse specificerer datatyperne og de operationer, som GraphQL API'en kan udføre.

Efter at forbindelsen til MongoDB-databasen er sat op, begynder serveren at lytte på port 5000.

Definer datamodellen

Opret en ny mappe i rodmappen i din projektmappe, og navngiv den modeller. I denne mappe skal du oprette nye filnavne dataModel.js og tilføje følgende kode til det:

konst {model, Skema} = kræve('mangust');
konst medarbejderSkema = ny Skema({
 navn: Snor,
 afdeling: Snor,
 løn: Snor,
});
modul.exports = model('Medarbejder', medarbejderskema);

Definer GraphQL-skemaet

Et GraphQL-skema definerer strukturen af ​​de data, som du kan forespørge ved hjælp af GraphQL API. Skemaet beskriver også de forespørgsler og mutationer, som API'en kan køre. Du kan bruge forespørgsler til at hente data og mutationer til at ændre dem.

Opret en ny mappe i dit projekts rodbibliotek, og navngiv den graphql. Tilføj to filer i denne mappe: typeDefs.js og resolvers.js

Tilføj koden nedenfor i typeDefs.js-filen:

konst {gql} = kræve("apollo-server");
konst typeDefs = gql`
 type Medarbejder {
 jeg gjorde!
 navn: Snor
 afdeling: Snor
 løn: Snor
 }
 input EmployeeInput {
 navn: Snor
 afdeling: Snor
 løn: Snor
 }
 skriv forespørgsel { 
 getEmployee (id: ID): Medarbejder #Vend tilbage Medarbejder efter id
 ansatte: [Medarbejder] #Vend tilbage array af Medarbejdere
 }
 type mutation {
 createEmployee (employeeInput: EmployeeInput): Medarbejder
 updateEmployee (id: ID, medarbejderinput: EmployeeInput): Boolean
 sletmedarbejder (id: ID): Boolean
 }
`;
modul.exports = typeDefs;

Denne kode ovenfor bruger gql funktion leveret af apollo-server-pakken til at oprette et GraphQL-skema for medarbejderdataene.

Skemaet består af fire hovedelementer: datatyper for medarbejderinformation, inputtyper, forespørgsler og mutationer, som API'en kan udføre.

Definer resolvere for GraphQL API

En resolver er en GraphQL-funktion, der definerer de data, der skal videregives, når en klient sender en API-forespørgsel for at hente data. Grundlæggende er dens primære rolle at hente de nødvendige data fra den angivne datakilde og returnere dem til klienten.

Tilføj koden nedenfor til resolvers.js fil i graphql folder. Resolverne er i dette tilfælde specificeret i forespørgsels- og mutationsobjekterne.

Forespørgselsobjektet definerer to metoder: medarbejdere og få medarbejder. Disse metoder er ansvarlige for at hente medarbejderdata fra databasen efter anmodning fra en klient.

konst Medarbejder= kræve("../models/employeesModel");
// GraphQL-resolvere
konst resolvere = {
 Forespørgsel: {
 medarbejdere: asynkron () => {
prøve {
konst ansatte = vente Medarbejder.find({});
Vend tilbage medarbejdere;
 } fangst (fejl) {
konsol.fejl (fejl);
kastenyFejl('Det lykkedes ikke at hente medarbejdere');
 }
 },
 get Employee: asynkron (forælder, args) => {
prøve {
konst medarbejder = vente Employee.findById (args.id);
Vend tilbage medarbejder;
 } fangst (fejl) {
konsol.fejl (fejl);
kastenyFejl('Det lykkedes ikke at hente medarbejder efter ID');
 }
 },
 },

Mutationsobjektet har tre metoder: skabe medarbejder, opdatere Medarbejder, og slet medarbejder. Disse metoder foretager ændringer i de data, der er gemt i MongoDB-databasen.

 Mutation: {
asynkron createEmployee (_, { medarbejderinput: { navn, afdeling, løn } }) {
konst nymedarbejder = ny Medarbejder({
 navn: navn,
 afdeling: afdeling,
 løn: løn
 });
konst svar = vente newEmployee.save();
konsol.log (ny medarbejder);
Vend tilbage {
 id: respons._id,
 ...svar._dok
 }
 },
asynkron updateEmployee (_, {id, medarbejderinput: {navn, afdeling, løn}}) {
konst opdateret Medarbejder = vente Employee.updateOne(
 { _id: id },
 { navn, afdeling, løn }
 );
hvis (!updatedEmployee) {
kastenyFejl(`Medarbejder med ID: ${id} ikke fundet');
 }
Vend tilbagerigtigt; // Returnerer en boolesk værdi, der angiver, at opdateringen er lykkedes
 },
asynkron deleteEmployee (_, {id}) {
konst slettet Medarbejder = vente Employee.deleteOne({ _id: id });

hvis (!deletedEmployee || deletedEmployee.deletedCount 0) {
kastenyFejl(`Medarbejder med ID ${id} ikke fundet');
 }
Vend tilbagerigtigt; // Returnerer en boolesk værdi, der indikerer sletning succes
 },
 },
};
modul.exports = resolvere;

Kør endelig denne kommando for at skrue serveren op:

node index.js

Når den har etableret en databaseforbindelse, starter serveren på port 5000.

Du kan gå videre og teste funktionaliteten af ​​GraphQL API ved at lave HTTP-anmodninger fra GraphQL-legepladsen i din browser.

For eksempel kan du bruge skabe medarbejder mutation for at tilføje nye medarbejderdata i MongoDB-databasen.

GraphQL-popularitet i udviklerfællesskabet

GraphQL vinder indpas i udviklerfællesskabet som en alternativ API-designtilgang til den populære REST-arkitektur.

Dette skyldes dets evne til at give en mere fleksibel og effektiv måde at hente data fra forskellige kilder på, alt sammen fra et enkelt indgangspunkt. Dette undgår at skulle administrere flere endepunkter for forskellige data, hvilket er et almindeligt problem med REST API-arkitektur. Denne designløsning strømliner processen med at bygge og administrere backend-API'er.