3 Go-baserede GraphQL-pakker til din næste API

Læsere som dig hjælper med at støtte MUO. Når du foretager et køb ved hjælp af links på vores websted, kan vi optjene en affiliate-kommission.

GraphQL er en HTTP-baseret specifikation, der løser de fleste af de problemer, du vil støde på, mens du bygger RESTful API'er. Det er velegnet til at bygge komplekse API'er, da du kan bruge ét slutpunkt til at få adgang til data fra mange skemaer.

GraphQL afbøder problemer som overhentning og underhentning i REST. Du kan bygge en klient, der anmoder om specifikke felter uden at skulle foretage ekstra API-kald.

Der er flere Go-pakker, du kan drage fordel af til at bygge GraphQL-baserede applikationer, fra servere til API'er.

1. Gqlgen-pakken

gqlgen (GraphQL Generator) er en funktionsrig, typesikker pakke til generering og opbygning af GraphQL-servere og API'er.

Gqlgen-pakken tager en skema-først tilgang, hvorved du bruger GraphQL SDL til at definere dit skema. Derefter genererer den boilerplate-koden, som du kan justere for at konfigurere din GraphQL-server og API.

gqlgen er en af ​​de mere komplette GraphQL-pakker i Go-økosystemet. Du kan generere dokumentation og eksempler med pakken og oprette forespørgsler, mutationer og abonnementer.

gqlgen sikrer typebindinger, indlejringer, grænseflader, genererede input og enums. Pakken giver også funktionalitet til åben sporing, hooks til fejllogning, dataindlæsning, samtidighed og øget forespørgselskompleksitet.

Efter at have defineret dit GraphQL-skema - som du ville gøre med ethvert schema-first-bibliotek - vil du bruge kommandolinjeappen gqlgen til at generere boilerplate-koden fra skemaet i dit projekt.

Lave en tools.go fil i din arbejdsmappe og tilføj disse kodelinjer for at inkludere gqlgen pakke:

// +byg værktøjer
pakke værktøjer
import _ "github.com/99designs/gqlgen"

Det tools.go fil specificerer byggeværktøjerne til gqlgen pakke.

Kør disse kommandoer i din arbejdsmappe for at installere gqlgen-pakken og dens afhængigheder:

gå installer github.com/99designs/gqlgen@latest
gå mod ryddeligt

Du kan initialisere et nyt GraphQL-projekt, når du kører GraphQL-pakken med i det kommando som argument:

gå kør github.com/99designs/gqlgen init

Du skal have dit skema i en schema.graphql fil placeret i din arbejdsmappe for at initialisere et projekt.

Kør server.go fil for at starte din GraphQL-server efter at have tilføjet funktionalitet til din GraphQL-app:

gå køre server.gå

2. graphql-go-pakken

graphql-go-pakken er et populært GraphQL-bibliotek, der har til formål at levere det komplette GraphQL udkast til specifikation til at bygge GraphQL-tjenester i Go.

Pakken graphql-go tager runtime type-tilgangen; du har mulighed for at erklære dit skema i Go-kode, og pakken kontrollerer runtime.

Du kan implementere forespørgsler, mutationer og abonnementer og generere eksempler med pakken, men der er ingen funktionalitet for genererede enums, input eller åben sporing.

graphql-go har en minimal API med understøttelse af både indbyggede pakker og populære tredjepartspakker. Den har støtte til OpenTelemetri og OpenTracing standarder, skematypekontrol mod resolvere, parallel eksekvering af resolvere og mange andre funktioner.

Hvis du er bekendt med opbygning af RESTful services i Go with the http pakke, du finder graphql-go-pakken nem at bruge.

Kør disse kommandoer i din arbejdsmappe for at tilføje pakken graphql-go og dens afhængigheder til dit projekt:

gå hent github.com/graph-gophers/graphql-gå

Her er et eksempel på at starte en simpel GraphQL-server:

pakke vigtigste
importere (
 "log"
 "net/http"
graphql "github.com/graph-gophers/graphql-gå"
 "github.com/graph-gophers/graphql-gå/relay"
)
type forespørgsel struktur{}
func(_ *forespørgsel)Hej()snor { Vend tilbage "Hej Verden!" }
funcvigtigste() {
 skemaEksempel := `
type Forespørgsel {
 hej: String!
 }
`
skema := graphql. MustParseSchema (schemaExample, &query{})
 http. Handle("/forespørgsel", &relæ. Handler{Skema: skema})
 log. Fatal (http. ListenAndServe(":8080", nul))
}

Det Hej metoden til forespørgsel struct er en resolver for GraphQL-slutpunktet, der returnerer hej verden. Det skemaEksempel variabel er skemadefinitionen, og serveren kører på port 8080 med http pakkens ListenAndServe metode.

3. Tordenpakken

Det Torden rammen tager struct first-tilgangen; du erklærer en struktur, der modellerer dit GraphQL-skema. Det genererer GraphQL skema fra Go-dataene til at håndtere forespørgselsbatching, live-forespørgsler, mutationer, abonnementer og eksempelgenerering.

Thunder giver typesikkerhed med typebindinger og andre funktioner, inklusive refleksionsbaseret skemabygning, indbygget parallel eksekvering og batching, en indbygget GraphiQL-editor og opdelte skemaer til større GraphQL servere.

Der er ingen funktionalitet for indlejring, grænseflader, genererede enums eller input, føderation, åben sporing eller brugerdefinerede fejl i Thunder-pakken. Det er dog en af ​​de nemmeste at bruge sammenlignet med andre populære pakker og er en glimrende startpakke, hvis du ikke har nogen GraphQL-erfaring.

Du skal køre denne kommando i terminalen i dit arbejdsbibliotek for at installere Thunder-pakken og dens afhængigheder:

gå få github.com/samsarahq/thunder/graphql

Du bliver nødt til at erklære en struct-model for skemaet, skrive resolverne og instansiere serveren for at starte en simpel GraphQL-server med Thunder-pakken.

importere (
 "sammenhæng"
 "net/http"
 "tid"
"github.com/samsarahq/thunder/graphql"
 "github.com/samsarahq/thunder/graphql/graphiql"
 "github.com/samsarahq/thunder/graphql/introspection"
 "github.com/samsarahq/thunder/graphql/schemabuilder"
 "github.com/samsarahq/thunder/reactive"
)
type stolpe struktur {
 Titel snor
 Legeme snor
 Oprettet på tidspunktet. Tid
}
// server er vores graphql server.
type server struktur {
 poster []post
}
// registerQuery registrerer rodforespørgselstypen.
func(s *server)registerForespørgsel(skema *schemabuilder. Skema) {
 obj := skema. Forespørgsel()
obj. FieldFunc("indlæg", func() []stolpe {
Vend tilbage s.indlæg
 })
}
// registerMutation registrerer rodmutationstypen.
func(s *server)registerMutation(skema *schemabuilder. Skema) {
 obj := skema. Mutation()
obj. FieldFunc("ekko", func(args struktur{ Besked snor })snor {
Vend tilbage args. Besked
 })
}
// registerPost registrerer posttypen.
func(s *server)tilmeld Post(skema *schemabuilder. Skema) {
 obj := skema. Objekt("Post", post{})
obj. FieldFunc("alder", func(ctx kontekst. Kontekst, p *post)snor {
 reaktive. InvalidateAfter (ctx, 5*tid. Anden)
Vend tilbage tid. Siden (s. CreatedAt).String()
 })
}
// skema bygger graphql-skemaet.
func(s *server)skema() *graphql.Skema {
 builder := schemabuilder. NewSchema()
 s.registerQuery (builder)
 s.registerMutation (builder)
 s.registerPost (bygger)
Vend tilbage Bygger. MustBuild()
}
funcvigtigste() {
// Instantiér en server, byg en server, og server skemaet på port 3030.
 server := &server{
 indlæg: []indlæg{
 {Titel: "første indlæg!", Body: "Jeg var her først!", Oprettet på: tidspunkt. Nu()},
 {Titel: "graphql", Body: "har du hørt om Thunder?", Oprettet på: tidspunkt. Nu()},
 },
 }
skema := server.schema()
 introspektion. AddIntrospectionToSchema (skema)
// Afslør skema og grafiql.
 http. Handle("/graphql", graphql. Handler (skema))
 http. Håndtag("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Handler()))
 http. ListenAndServe(":3030", nul)
}

Det stolpe struct er modellen for GraphQL-skemaet, og server struct er serverforekomsten. Det registerForespørgsel, registerMutation, og tilmeld Post metoder er resolverfunktioner til forespørgsler, mutationer og datalagring.

Det vigtigste funktionen starter med GraphQL-serveren på port 3030 og GraphQL-editoren.

Du kan forespørge GraphQL API'er på vej med indbyggede pakker

GraphQL er HTTP-baseret, og du kan bruge GraphQL API'er med den indbyggede http pakke og andre pakker, der ligner RESTful API'er. Der er også pakker i Go's økosystem, der giver dig mulighed for hurtigt at forbruge GraphQL API'er.