3 Go-Based GraphQL-paket för ditt nästa API

Läsare som du hjälper till att stödja MUO. När du gör ett köp med hjälp av länkar på vår webbplats kan vi tjäna en affiliate-provision.

GraphQL är en HTTP-baserad specifikation som löser de flesta problem du kommer att stöta på när du bygger RESTful API: er. Det är lämpligt för att bygga komplexa API: er eftersom du kan använda en slutpunkt för att komma åt data från många scheman.

GraphQL mildrar problem som överhämtning och underhämtning i REST. Du kan bygga en klient som begär specifika fält utan att behöva göra extra API-anrop.

Det finns flera Go-paket du kan dra nytta av för att bygga GraphQL-baserade applikationer, från servrar till API: er.

1. Paketet gqlgen

gqlgen (GraphQL Generator) är ett funktionsrikt, typsäkert paket för att generera och bygga GraphQL-servrar och API: er.

Paketet gqlgen använder ett schema-först-tillvägagångssätt, genom vilket du använder GraphQL SDL för att definiera ditt schema. Den genererar sedan boilerplate-koden som du kan justera för att ställa in din GraphQL-server och API.

gqlgen är ett av de mer kompletta GraphQL-paketen i Go-ekosystemet. Du kan generera dokumentation och exempel med paketet och skapa frågor, mutationer och prenumerationer.

gqlgen säkerställer typbindningar, inbäddningar, gränssnitt, genererade indata och enums. Paketet tillhandahåller även funktionalitet för öppen spårning, krokar för felloggning, dataladdning, samtidighet och ökad frågekomplexitet.

Efter att ha definierat ditt GraphQL-schema – som du skulle göra med alla schema-first-bibliotek – kommer du att använda kommandoradsappen gqlgen för att generera standardkoden från schemat i ditt projekt.

Skapa en tools.go fil i din arbetskatalog och lägg till dessa kodrader för att inkludera gqlgen paket:

// +byggverktyg
paket verktyg
importera _ "github.com/99designs/gqlgen"

De tools.go fil anger byggverktygen för gqlgen paket.

Kör dessa kommandon i din arbetskatalog för att installera paketet gqlgen och dess beroenden:

gå installera github.com/99designs/gqlgen@latest
gå mod städat

Du kan initiera ett nytt GraphQL-projekt när du kör GraphQL-paketet med i det kommando som ett argument:

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

Du måste ha ditt schema i en schema.graphql fil som finns i din arbetskatalog för att initiera ett projekt.

Springa det server.go fil för att starta din GraphQL-server efter att ha lagt till funktionalitet till din GraphQL-app:

gå kör server.gå

2. graphql-go-paketet

Paketet graphql-go är ett populärt GraphQL-bibliotek som syftar till att tillhandahålla hela GraphQL-utkastspecifikation för att bygga GraphQL-tjänster i Go.

Paketet graphql-go använder körtidstyperna; du har möjlighet att deklarera ditt schema i Go-kod, och paketet kontrollerar vid körning.

Du kan implementera frågor, mutationer och prenumerationer och generera exempel med paketet, men det finns ingen funktionalitet för genererade enums, indata eller öppen spårning.

graphql-go har ett minimalt API med stöd för både inbyggda paket och populära tredjepartspaket. Den har stöd för Öppna Telemetri och OpenTracing standarder, kontroll av schematyp mot resolvers, parallell exekvering av resolvers och många andra funktioner.

Om du är bekant med bygga RESTful tjänster i Go with the http paket, du hittar paketet graphql-go lätt att använda.

Kör dessa kommandon i din arbetskatalog för att lägga till paketet graphql-go och dess beroenden till ditt projekt:

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

Här är ett exempel på att starta en enkel GraphQL-server:

paket huvud
importera (
 "logga"
 "net/http"
graphql "github.com/graph-gophers/graphql-gå"
 "github.com/graph-gophers/graphql-gå/relay"
)
typ fråga struktur{}
func(_ *fråga)Hallå()sträng { lämna tillbaka "Hej världen!" }
funchuvud() {
 schemaExempel := `
typ Fråga {
 hej: String!
 }
`
schema := graphql. MustParseSchema (schemaExample, &query{})
 http. Handle("/query", &relay. Hanterare{Schema: schema})
 logga. Fatal (http. ListenAndServe(":8080", noll))
}

De Hallå metod för fråga struct är en resolver för GraphQL-slutpunkten som returnerar hello world. De schemaExempel variabel är schemadefinitionen, och servern kommer att köras på port 8080 med http paketets ListenAndServe metod.

3. Thunder-paketet

De åska ram tar struct first approach; du deklarerar en struktur som modellerar ditt GraphQL-schema. Det genererar GraphQL-schema från Go-data för att hantera frågebatchning, liveförfrågningar, mutationer, prenumerationer och exempelgenerering.

Thunder ger typsäkerhet med typbindningar och andra funktioner, inklusive reflektionsbaserad schemabyggnad, inbyggd parallellkörning och batchning, en inbyggd GraphiQL-redigerare och delade scheman för större GraphQL servrar.

Det finns ingen funktionalitet för inbäddning, gränssnitt, genererade enum eller indata, federation, öppen spårning eller anpassade fel i Thunder-paketet. Det är dock ett av de enklaste att använda jämfört med andra populära paket och är ett utmärkt startpaket om du inte har någon GraphQL-erfarenhet.

Du måste köra det här kommandot i terminalen i din arbetskatalog för att installera Thunder-paketet och dess beroenden:

gå hämta github.com/samsarahq/thunder/graphql

Du måste deklarera en struct-modell för schemat, skriva resolvers och instansiera servern för att starta en enkel GraphQL-server med Thunder-paketet.

importera (
 "sammanhang"
 "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"
)
typ posta struktur {
 Titel sträng
 Kropp sträng
 Skapade vid tidpunkten. Tid
}
// server är vår graphql-server.
typ server struktur {
 inlägg []post
}
// registerQuery registrerar rotfrågetypen.
func(s *server)registerQuery(schema *schemabyggare. Schema) {
 obj := schema. Fråga()
obj. FieldFunc("inlägg", func() []posta {
lämna tillbaka s.inlägg
 })
}
// registerMutation registrerar rotmutationstypen.
func(s *server)registerMutation(schema *schemabyggare. Schema) {
 obj := schema. Mutation()
obj. FieldFunc("eko", func(args struktur{ Meddelande sträng })sträng {
lämna tillbaka args. Meddelande
 })
}
// registerPost registrerar posttypen.
func(s *server)registrera Post(schema *schemabyggare. Schema) {
 obj := schema. Objekt("Inlägg", post{})
obj. FieldFunc("ålder", func(ctx sammanhang. Kontext, p *post)sträng {
 reaktiv. InvalidateAfter (ctx, 5*tid. Andra)
lämna tillbaka tid. Sedan (s. CreatedAt).String()
 })
}
// schema bygger graphql-schemat.
func(s *server)schema() *graphql.Schema {
 byggare := schemabyggare. NewSchema()
 s.registerQuery (byggare)
 s.registerMutation (byggare)
 s.registerPost (byggare)
lämna tillbaka byggare. MustBuild()
}
funchuvud() {
// Instantiera en server, bygg en server och servera schemat på port 3030.
 server := &server{
 inlägg: []post{
 {Titel: "första inlägget!", Body: "Jag var här först!", Skapad vid: tid. Nu()},
 {Titel: "graphql", Body: "har du hört talas om Thunder?", Skapad vid: tidpunkt. Nu()},
 },
 }
schema := server.schema()
 introspektion. AddIntrospectionToSchema (schema)
// Exponera schema och grafiql.
 http. Handle("/graphql", graphql. Hanterare (schema))
 http. Handle("/graphiql/", http. StripPrefix("/graphiql/", graphiql. Hanterare()))
 http. ListenAndServe(":3030", noll)
}

De posta struct är modellen för GraphQL-schemat, och server struct är serverinstansen. De registerQuery, registerMutation, och registrera Post metoder är resolverfunktioner för frågor, mutationer och datalagring.

De huvud funktionen startar med GraphQL-servern på port 3030 och GraphQL-redigeraren.

Du kan fråga GraphQL API: er samtidigt med inbyggda paket

GraphQL är HTTP-baserat och du kan använda GraphQL API: er med det inbyggda http paket och andra paket som liknar RESTful API: er. Det finns också paket i Gos ekosystem som gör att du snabbt kan konsumera GraphQL API: er.