Jak zbudować API GraphQL z Apollo Server i MongoDB

Jednym z najważniejszych czynników, które należy wziąć pod uwagę podczas projektowania aplikacji, jest typ używanej architektury API. Wydajny projekt interfejsu API ma kluczowe znaczenie dla zapewnienia wydajności aplikacji przez cały cykl ich życia.

Architektura RESTful jest najpopularniejszym podejściem, ale ma jedną istotną wadę: stałą strukturę punktu końcowego, która zwraca z góry określone dane. Taka konstrukcja może skutkować nieefektywną komunikacją.

Z kolei GraphQL — alternatywa dla REST — oferuje większą elastyczność, pozwalając żądać tylko tych danych, których potrzebujesz.

Czym są interfejsy API GraphQL?

GraphQL to język zapytań, którego można używać do pisania interfejsów API zaplecza (interfejsów programowania aplikacji). w odróżnieniu API REST, które mają wiele punktów końcowych dla różnych danych, interfejsy API GraphQL mają tylko jeden punkt wejścia.

Klienci mogą określać dane, których potrzebują w swoich zapytaniach z tego pojedynczego punktu wejścia, co czyni go bardziej elastycznym i wydajnym w pobieraniu tylko niezbędnych danych.

Mówiąc najprościej, GraphQL API implementuje architekturę GraphQL opisaną przez Specyfikacje GraphQL. Ten projekt obejmuje zdefiniowanie schematu, zapytań i mutacji, z którymi klienci mogą wchodzić w interakcje.

Oto uproszczony podział podstawowych komponentów architektury GraphQL API:

1. Schemat: schemat to opis typów danych i operacji udostępnianych przez interfejs API. Zasadniczo schemat definiuje strukturę dostępnych danych oraz typ zapytań i mutacji, które klient może wykonać w celu zmodyfikowania danych.
2. Zapytania: Klienci używają zapytań do pobierania danych z bazy danych, określając strukturę wymaganych danych. Ponadto mogą zagnieżdżać wiele zapytań w jednym żądaniu HTTP w celu pobierania powiązanych danych z wielu punktów końcowych.
3. Mutacje: Mutacje to operacje używane do modyfikowania danych w bazie danych. Klienci mogą wysyłać żądania mutacji w celu tworzenia, aktualizowania lub usuwania danych.

Skonfiguruj bazę danych MongoDB

Rozpocząć, utwórz bazę danych MongoDB. Alternatywnie możesz bezpłatnie skonfiguruj klaster MongoDB w chmurze.Po skonfigurowaniu bazy danych skopiuj ciąg URI połączenia z bazą danych MongoDB.

Możesz znaleźć kod tego projektu w jego Repozytorium GitHub.

Utwórz serwer Apollo

Serwer Apollo to popularna implementacja serwera GraphQL, która pozwoli Ci budować interfejsy API GraphQL w środowiskach JavaScript, w tym Node.js, Express i innych.

Utwórz katalog dla nowego projektu i płyta CD w tym:

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

Następnie zainicjuj nowy projekt Node.js.

npm init -- tak

To polecenie tworzy plik pakiet.json plik.

Zainstaluj wymagane zależności

Uruchom następujące polecenie, aby zainstalować pakiety.

npm zainstaluj apollo-server graphql mangusta

Na koniec utwórz plik indeks.js plik w katalogu głównym projektu.

Skonfiguruj serwer Apollo

otwarty indeks.js i dodaj poniższy kod:

konst { Serwer Apollo } = wymagać('serwer apollo');
konst mangusta = wymagać('mangusta');
konst typeDefs = wymagać("./graphql/typeDefs");
konst resolwery = wymagać("./graphql/resolwery");
konst serwer = nowy ApolloServer({
 typeDefs, 
 resolwery 
});
konst MONGO_URI = 'mongodb://localhost: 27017';
mangusta
 .connect (MONGO_URI, {
 useNewUrlParser: PRAWDA,
 użyj ujednoliconej topologii: PRAWDA,
 })
 .Następnie(() => {
konsola.dziennik(`Db podłączony`);
powrót serwer.słuchaj({ Port: 5000 });
 })
 .Następnie((rez) => {
konsola.dziennik(`Serwer działający pod adresem ${res.url}`);
 })
 .złapać(błądzić => {
konsola.log (komunikat o błędzie);
 });

Ten kod inicjuje lokalny serwer GraphQL przy użyciu biblioteki Apollo Server. Następnie ustanawia połączenie z bazą danych MongoDB z podanym identyfikatorem URI połączenia.

Zwróć uwagę, jak kod przekazuje dwa argumenty do nowej instancji ApolloServer: typeDefs i resolvers. Określają one typy danych i operacje, które może wykonać API GraphQL.

Po nawiązaniu połączenia z bazą danych MongoDB serwer zaczyna nasłuchiwać na porcie 5000.

Zdefiniuj model danych

Utwórz nowy folder w katalogu głównym folderu projektu i nadaj mu nazwę modele. W tym folderze utwórz nowe nazwy plików dataModel.js i dodaj do niego następujący kod:

konst {model, schemat} = wymagać('mangusta');
konst schemat pracownika = nowy Schemat({
 nazwa: Strunowy,
 dział: Strunowy,
 wynagrodzenie: Strunowy,
});
moduł.eksport = model('Pracownik', schemat pracownika);

Zdefiniuj schemat GraphQL

Schemat GraphQL definiuje strukturę danych, które można przeszukiwać przy użyciu interfejsu API GraphQL. Schemat przedstawia również zapytania i mutacje, które może uruchamiać interfejs API. Możesz użyć zapytań do pobrania danych i mutacji, aby je zmodyfikować.

W katalogu głównym projektu utwórz nowy folder i nadaj mu nazwę wykresql. Wewnątrz tego folderu dodaj dwa pliki: typeDefs.js I resolvers.js

Dodaj poniższy kod w pliku typeDefs.js:

konst {gql} = wymagać("serwer apollo");
konst typeDefs = gql`
 wpisz Pracownik {
 Zrobiłem!
 nazwa: Strunowy
 dział: Strunowy
 wynagrodzenie: Strunowy
 }
 wprowadź dane pracownika {
 nazwa: Strunowy
 dział: Strunowy
 wynagrodzenie: Strunowy
 }
 wpisz zapytanie { 
 getEmployee (id: ID): Numer pracownikapowrót Pracownik według identyfikatora
 pracownicy: [Pracownik] #powrót szyk z Pracownicy
 }
 wpisz mutację {
 createEmployee (employeeInput: EmployeeInput): Pracownik
 updatePracownik (id: ID, wejście pracownika: Wejście pracownika): logiczne
 usuńPracownika (identyfikator: identyfikator): logiczne
 }
`;
moduł.exports = typeDefs;

Powyższy kod używa gql funkcja dostarczana przez pakiet apollo-server do tworzenia schematu GraphQL dla danych pracownika.

Schemat składa się z czterech głównych elementów: typów danych dla informacji o pracownikach, typów danych wejściowych, zapytań i mutacji, które może wykonać API.

Zdefiniuj Resolvery dla API GraphQL

Resolwer to funkcja GraphQL, która definiuje dane, które mają być przekazywane, gdy klient wysyła zapytanie API w celu pobrania danych. Zasadniczo jego podstawową rolą jest pobranie wymaganych danych z określonego źródła danych i zwrócenie ich klientowi.

Dodaj poniższy kod do pliku resolvers.js plik w wykresql teczka. Resolwery w tym przypadku są określone w obiektach Query i Mutation.

Obiekt Query definiuje dwie metody: pracownicy I pobierzPracownika. Metody te odpowiadają za pobieranie danych pracowników z bazy danych na żądanie klienta.

konst pracownik= wymagać(„../modele/pracownicyModel”);
// Resolwery GraphQL
konst resolwery = {
 Zapytanie: {
 pracownicy: asynchroniczny () => {
próbować {
konst pracownicy = czekać na pracownik.znajdź({});
powrót pracownicy;
 } złapać (błąd) {
konsola.błąd (błąd);
rzucićnowyBłąd(„Nie udało się pobrać pracowników”);
 }
 },
 pobierzPracownika: asynchroniczny (rodzic, argumenty) => {
próbować {
konst pracownik = czekać na Pracownik.znajdźById (args.id);
powrót pracownik;
 } złapać (błąd) {
konsola.błąd (błąd);
rzucićnowyBłąd(„Nie udało się pobrać pracownika według identyfikatora”);
 }
 },
 },

Obiekt Mutation ma trzy metody: utwórz Pracownika, aktualizacjaPracownik, I usuńPracownik. Te metody dokonują zmian w danych przechowywanych w bazie danych MongoDB.

 Mutacja: {
asynchroniczny utwórzPracownika (_, { wejście pracownika: { nazwisko, dział, wynagrodzenie } }) {
konst nowyPracownik = nowy Pracownik({
 Nazwa nazwa,
 dział: dział,
 wynagrodzenie: wynagrodzenie
 });
konst odpowiedź = czekać na nowyPracownik.save();
konsola.log (nowyPracownik);
powrót {
 identyfikator: odpowiedź._id,
 ...odpowiedź._doc
 }
 },
asynchroniczny aktualizacjapracownika (_, {id, wejście pracownika: {nazwisko, dział, wynagrodzenie}}) {
konst zaktualizowanyPracownik = czekać na Pracownik.updateOne(
 { _ID: ID },
 { nazwisko, dział, wynagrodzenie }
 );
Jeśli (! zaktualizowany pracownik) {
rzucićnowyBłąd(`Pracownik o identyfikatorze: ${identyfikator} nie znaleziono`);
 }
powrótPRAWDA; // Zwraca wartość logiczną wskazującą powodzenie aktualizacji
 },
asynchroniczny usuńPracownika (_, {id}) {
konst usuniętoPracownik = czekać na Pracownik.deleteOne({ _ID: ID });

Jeśli (!usuniętyPracownik ||usuniętyEmployee.deletedCount 0) {
rzucićnowyBłąd(`Pracownik z identyfikatorem ${identyfikator} nie znaleziono`);
 }
powrótPRAWDA; // Zwraca wartość logiczną wskazującą na pomyślne usunięcie
 },
 },
};
moduł.exports = resolwery;

Na koniec uruchom to polecenie, aby rozkręcić serwer:

węzeł index.js

Po nawiązaniu połączenia z bazą danych serwer uruchomi się na porcie 5000.

Możesz śmiało przetestować funkcjonalność GraphQL API, wysyłając żądania HTTP z placu zabaw GraphQL w swojej przeglądarce.

Na przykład możesz użyć tzw utwórz Pracownika mutacja w celu dodania nowych danych pracowników w bazie MongoDB.

Popularność GraphQL w społeczności programistów

GraphQL zyskuje popularność w społeczności programistów jako alternatywne podejście do projektowania API dla popularnej architektury REST.

Wynika to z możliwości zapewnienia bardziej elastycznego i wydajnego sposobu pobierania danych z różnych źródeł, a wszystko to z jednego punktu wejścia. Pozwala to uniknąć konieczności zarządzania wieloma punktami końcowymi dla różnych danych, co jest częstym problemem związanym z architekturą REST API. To rozwiązanie do projektowania usprawnia proces tworzenia interfejsów API zaplecza i zarządzania nimi.