Jak vytvořit GraphQL API s Apollo Server a MongoDB

Jedním z nejdůležitějších faktorů, které je třeba vzít v úvahu při navrhování aplikace, je typ architektury API, který se má použít. Efektivní návrh rozhraní API je zásadní pro zajištění výkonnosti aplikací po celou dobu jejich životního cyklu.

Architektura RESTful je nejoblíbenější přístup, ale má jednu významnou nevýhodu: pevnou strukturu koncového bodu, která vrací předem určená data. Tento návrh může mít za následek neefektivní komunikaci.

Naproti tomu GraphQL – alternativa k REST – nabízí větší flexibilitu tím, že vám umožňuje požadovat pouze ta data, která potřebujete.

Co jsou GraphQL API?

GraphQL je dotazovací jazyk, který můžete použít k psaní backendových API (Application Programming Interfaces). Na rozdíl od REST API, které mají více koncových bodů pro různá data, mají rozhraní GraphQL API pouze jeden vstupní bod.

Klienti mohou specifikovat data, která potřebují ve svých dotazech z tohoto jediného vstupního bodu, což je flexibilnější a efektivnější pro získávání pouze nezbytných dat.

Jednoduše řečeno, GraphQL API implementuje architekturu GraphQL popsanou v Specifikace GraphQL. Tento návrh zahrnuje definování schématu, dotazů a mutací, se kterými mohou klienti pracovat.

Zde je zjednodušený rozpis základních komponent architektury GraphQL API:

1. Schéma: Schéma je popis typů dat a operací, které API poskytuje. Schéma v zásadě definuje strukturu dostupných dat a typ dotazů a mutací, které může klient provést za účelem úpravy dat.
2. Dotazy: Klienti používají dotazy k načítání dat z databáze zadáním struktury požadovaných dat. Navíc mohou vnořit více dotazů do jednoho požadavku HTTP, aby načetli související data z více koncových bodů.
3. Mutace: Mutace jsou operace používané k úpravě dat v databázi. Klienti mohou zasílat požadavky na mutaci za účelem vytvoření, aktualizace nebo odstranění dat.

Nastavte databázi MongoDB

Začít, vytvořit databázi MongoDB. Případně můžete zdarma nastavit cluster MongoDB v clouduJakmile budete mít databázi nastavenou, zkopírujte řetězec URI připojení databáze MongoDB.

Kód tohoto projektu najdete v něm úložiště GitHub.

Vytvořte server Apollo

Server Apollo je populární implementace serveru GraphQL, která vám umožní vytvářet rozhraní API GraphQL v prostředí JavaScriptu, včetně Node.js, Express a dalších.

Vytvořte adresář pro nový projekt a CD do toho:

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

Dále inicializujte nový projekt Node.js.

npm init --ano

Tento příkaz vytvoří a package.json soubor.

Nainstalujte požadované závislosti

Spuštěním následujícího příkazu nainstalujte balíčky.

npm nainstalovat apollo-server graphql mongoose

Nakonec vytvořte index.js soubor v kořenovém adresáři vašeho projektu.

Nastavte server Apollo

OTEVŘENO index.js a přidejte kód níže:

konst { ApolloServer } = vyžadovat('apollo-server');
konst mangusta = vyžadovat('mangusta');
konst typeDefs = vyžadovat("./graphql/typeDefs");
konst řešitelé = vyžadovat("./graphql/resolvers");
konst server = Nový ApolloServer({
 typeDefs, 
 řešitelé 
});
konst MONGO_URI = 'mongodb://localhost: 27017';
mangusta
 .connect (MONGO_URI, {
 useNewUrlParser: skutečný,
 useUnifiedTopology: skutečný,
 })
 .pak(() => {
řídicí panel.log("Db připojeno".);
vrátit se server.listen({ přístav: 5000 });
 })
 .pak((res) => {
řídicí panel.log(`Server běží na ${res.url}`);
 })
 .chytit(chybovat => {
řídicí panel.log (chyba.zprava);
 });

Tento kód inicializuje místní server GraphQL pomocí knihovny serveru Apollo. Poté naváže připojení k databázi MongoDB s daným URI připojení.

Všimněte si, jak kód předává dva argumenty nové instanci ApolloServer: typeDefs a resolvery. Ty určují datové typy a operace, které může rozhraní GraphQL API provádět.

Po nastavení připojení k databázi MongoDB začne server naslouchat na portu 5000.

Definujte datový model

Vytvořte novou složku v kořenovém adresáři složky projektu a pojmenujte ji modely. V této složce vytvořte nové názvy souborů dataModel.js a přidejte do něj následující kód:

konst {model, schéma} = vyžadovat('mangusta');
konst zaměstnanecSchema = Nový Schéma({
 název: Tětiva,
 oddělení: Tětiva,
 plat: Tětiva,
});
modul.exports = model('Zaměstnanec', zaměstnanecSchema);

Definujte schéma GraphQL

Schéma GraphQL definuje strukturu dat, která můžete dotazovat pomocí GraphQL API. Schéma také popisuje dotazy a mutace, které může API spouštět. Můžete použít dotazy k načtení dat a mutace k jejich úpravě.

V kořenovém adresáři projektu vytvořte novou složku a pojmenujte ji graphql. Do této složky přidejte dva soubory: typeDefs.js a resolvers.js

Přidejte níže uvedený kód do souboru typeDefs.js:

konst {gql} = vyžadovat("apollo-server");
konst typeDefs = gql`
 typ Zaměstnanec {
 udělal jsem!
 název: Tětiva
 oddělení: Tětiva
 plat: Tětiva
 }
 input EmployeeInput {
 název: Tětiva
 oddělení: Tětiva
 plat: Tětiva
 }
 zadejte dotaz { 
 getEmployee (id: ID): Číslo zaměstnancevrátit se Zaměstnanec podle id
 zaměstnanci: [Zaměstnanec] #vrátit se pole z Zaměstnanci
 }
 type Mutation {
 createEmployee (employeeInput: EmployeeInput): Zaměstnanec
 updateEmployee (id: ID, zaměstnanecInput: Zaměstnanec): Boolean
 deleteEmployee (id: ID): Boolean
 }
`;
modul.exports = typeDefs;

Tento výše uvedený kód používá gql funkce poskytovaná balíčkem apollo-server k vytvoření schématu GraphQL pro data zaměstnance.

Schéma se skládá ze čtyř hlavních prvků: datových typů pro informace o zaměstnancích, vstupních typů, dotazů a mutací, které může API provádět.

Definujte Resolvery pro GraphQL API

Překladač je funkce GraphQL, která definuje data, která mají být předána, když klient odešle dotaz API k načtení dat. Jeho primární rolí je v podstatě načíst požadovaná data ze zadaného zdroje dat a vrátit je klientovi.

Přidejte níže uvedený kód do resolvers.js soubor v graphql složku. Překladače jsou v tomto případě specifikovány v objektech Query a Mutation.

Objekt Query definuje dvě metody: zaměstnanci a getEmployee. Tyto metody jsou zodpovědné za získávání údajů o zaměstnancích z databáze na žádost klienta.

konst Zaměstnanec = vyžadovat("../models/employeesModel");
// Resolvery GraphQL
konst resolvery = {
 Dotaz: {
 zaměstnanci: asynchronní () => {
Snaž se {
konst zaměstnanci = čekat Employee.find({});
vrátit se zaměstnanci;
 } chytit (chyba) {
řídicí panel.chyba (chyba);
házetNovýChyba("Nepodařilo se načíst zaměstnance");
 }
 },
 getEmployee: asynchronní (rodič, argumenty) => {
Snaž se {
konst zaměstnanec = čekat Employee.findById (args.id);
vrátit se zaměstnanec;
 } chytit (chyba) {
řídicí panel.chyba (chyba);
házetNovýChyba("Nepodařilo se načíst zaměstnance podle ID");
 }
 },
 },

Objekt Mutation má tři metody: vytvořitZaměstnance, aktualizovatZaměstnanec, a odstranitZaměstnance. Tyto metody provádějí změny v datech uložených v databázi MongoDB.

 Mutace: {
asynchronní createEmployee (_, { zaměstnanecInput: { jméno, oddělení, plat } }) {
konst novýZaměstnanec = Nový Zaměstnanec({
 jméno: jméno,
 oddělení: oddělení,
 plat: plat
 });
konst odpověď = čekat novyZamestnanec.save();
řídicí panel.log (novýZaměstnanec);
vrátit se {
 id: response._id,
 ...odpověď._doc
 }
 },
asynchronní updateEmployee (_, {id, zaměstnanecInput: {jméno, oddělení, plat}}) {
konst aktualizovánoZaměstnanec = čekat Employee.updateOne(
 { _id: id },
 { jméno, oddělení, plat }
 );
-li (!updatedEmployee) {
házetNovýChyba(„Zaměstnanec s ID: ${id} nenalezen');
 }
vrátit seskutečný; // Vrátí booleovskou hodnotu označující úspěšnou aktualizaci
 },
asynchronní deleteEmployee (_, {id}) {
konst smazánoZaměstnanec = čekat Employee.deleteOne({ _id: id});

-li (!deletedEmployee || deleteEmployee.deletedCount 0) {
házetNovýChyba(„Zaměstnanec s ID ${id} nenalezen');
 }
vrátit seskutečný; // Vrátí booleovskou hodnotu označující úspěch smazání
 },
 },
};
modul.export = resolvery;

Nakonec spusťte tento příkaz pro spuštění serveru:

node index.js

Jakmile naváže připojení k databázi, server se spustí na portu 5000.

Můžete pokračovat a otestovat funkčnost GraphQL API zadáním požadavků HTTP z hřiště GraphQL ve vašem prohlížeči.

Můžete například použít vytvořitZaměstnance mutace pro přidání nových údajů o zaměstnancích do databáze MongoDB.

Popularita GraphQL v komunitě vývojářů

GraphQL si získává pozornost ve vývojářské komunitě jako alternativní přístup k návrhu API k populární architektuře REST.

To je způsobeno jeho schopností poskytovat flexibilnější a efektivnější způsob získávání dat z různých zdrojů, to vše z jediného vstupního bodu. Tím se vyhnete nutnosti spravovat více koncových bodů pro různá data, což je běžný problém architektury REST API. Toto návrhové řešení zjednodušuje proces vytváření a správy backendových rozhraní API.