GraphQL é uma especificação baseada em HTTP que resolve a maioria dos problemas que você encontrará ao erigir APIs RESTful. É adequado para produzir APIs complexas, pois você pode usar um endpoint para acessar dados de vários esquemas.
O GraphQL atenua problemas uma vez que procura excessiva e insuficiente em REST. Você pode produzir um cliente que solicite campos específicos sem precisar fazer chamadas de API extras.
Existem vários pacotes Go que você pode aproveitar para produzir aplicativos baseados em GraphQL, de servidores a APIs.
1. O pacote gqlgen
gqlgen (GraphQL Generator) é um pacote rico em recursos e seguro para gerar e erigir servidores e APIs GraphQL.
O pacote gqlgen adota uma abordagem que prioriza o esquema, na qual você usa o GraphQL SDL para definir seu esquema. Em seguida, ele gera o código clichê que você pode ajustar para configurar seu servidor e API GraphQL.
gqlgen é um dos pacotes GraphQL mais completos do ecossistema Go. Você pode gerar documentação e exemplos com o pacote e produzir consultas, mutações e assinaturas.
gqlgen garante ligações de tipo, embeddings, interfaces, entradas geradas e enums. O pacote também fornece funcionalidade para rastreamento cândido, ganchos para registro de erros, carregamento de dados, simultaneidade e maior complicação de consulta.
Depois de definir seu esquema do GraphQL, uma vez que faria com qualquer livraria de esquema em primeiro lugar, você usará o aplicativo de risca de comando gqlgen para gerar o código clichê do esquema em seu projeto.
Crie um ferramentas.go registo em seu diretório de trabalho e adicione essas linhas de código para incluir o gqlgen pacote:
package tools
import _ "github.com/99designs/gqlgen"
o ferramentas.go registo especifica as ferramentas de compilação para o gqlgen pacote.
Execute estes comandos em seu diretório de trabalho para instalar o pacote gqlgen e suas dependências:
go install github.com/99designs/gqlgen@latest
go mod tidyVocê pode inicializar um novo projeto GraphQL ao executar o pacote GraphQL com o iniciar comando uma vez que argumento:
go run github.com/99designs/gqlgen init
Você precisará ter seu esquema em um schema.graphql registo localizado em seu diretório de trabalho para inicializar um projeto.
Execute o servidor.go para iniciar seu servidor GraphQL depois de somar funcionalidade ao seu aplicativo GraphQL:
go run server.go2. O pacote graphql-go
O pacote graphql-go é uma livraria GraphQL popular que visa fornecer a especificação de rascunho completa do GraphQL para a construção de serviços GraphQL em Go.
O pacote graphql-go adota a abordagem de tipos de tempo de realização; você tem a opção de declarar seu esquema no código Go e o pacote verifica em tempo de realização.
Você pode implementar consultas, mutações e assinaturas e gerar exemplos com o pacote, mas não há funcionalidade para enums gerados, entradas ou rastreamento cândido.
graphql-go apresenta uma API mínima com suporte para pacotes integrados e populares de terceiros. Possui suporte para OpenTelemetry e OpenTracing padrões, verificação de tipo de esquema em relação a resolvedores, realização paralela de resolvedores e muitos outros recursos.
Se você estiver familiarizado com a geração de serviços RESTful em Go com o http pacote, você achará o pacote graphql-go fácil de usar.
Execute estes comandos em seu diretório de trabalho para somar o pacote graphql-go e suas dependências ao seu projeto:
go get github.com/graph-gophers/graphql-go
Cá está um exemplo de uma vez que iniciar um servidor GraphQL simples:
package mainimport (
"log"
"net/http"
graphql "github.com/graph-gophers/graphql-go"
"github.com/graph-gophers/graphql-go/relay"
)
type query struct{}
func (_ *query) Hello() string { return "Hello, world!" }
func main() {
schemaExample := `
type Query {
hello: String!
}
`
schema := graphql.MustParseSchema(schemaExample, &query{})
http.Handle("/query", &relay.Handler{Schema: schema})
log.Trágico(http.ListenAndServe(":8080", nil))
}
o Olá método do consulta struct é um resolvedor para o endpoint GraphQL que retorna hello world. o esquemaExemplo variável é a definição do esquema e o servidor será executado na porta 8080 com a http pacote Ouvir e servir método.
3. O Pacote Thunder
A estrutura Thunder adota a abordagem struct first; você declara um struct que modela seu esquema GraphQL. Ele gera o esquema GraphQL a partir dos dados Go para mourejar com lotes de consultas, consultas em tempo real, mutações, assinaturas e geração de exemplos.
O Thunder fornece segurança de tipo com associações de tipo e outros recursos, incluindo construção de esquema baseada em reflexão, realização paralela e lotes integrados, um editor GraphiQL integrado e esquemas divididos para servidores GraphQL maiores.
Não há funcionalidade para incorporação, interfaces, enumerações ou entradas geradas, federação, rastreamento cândido ou erros personalizados no pacote Thunder. No entanto, é um dos mais fáceis de usar em confrontação com outros pacotes populares e é um supimpa pacote inicial se você não tiver experiência em GraphQL.
Você precisará executar oriente comando no terminal do seu diretório de trabalho para instalar o pacote Thunder e suas dependências:
go get github.com/samsarahq/thunder/graphql
Você precisará declarar um protótipo de estrutura para o esquema, grafar os resolvedores e instanciar o servidor para iniciar um servidor GraphQL simples com o pacote Thunder.
import (
"context"
"net/http"
"time""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 post struct {
Title string
Body string
CreatedAt time.Time
}
type server struct {
posts []post
}
func (s *server) registerQuery(schema *schemabuilder.Schema) {
obj := schema.Query()
obj.FieldFunc("posts", func() []post {
return s.posts
})
}
func (s *server) registerMutation(schema *schemabuilder.Schema) {
obj := schema.Mutation()
obj.FieldFunc("echo", func(args struct{ Message string }) string {
return args.Message
})
}
func (s *server) registerPost(schema *schemabuilder.Schema) {
obj := schema.Object("Post", post{})
obj.FieldFunc("age", func(ctx context.Context, p *post) string {
reactive.InvalidateAfter(ctx, 5*time.Second)
return time.Since(p.CreatedAt).String()
})
}
func (s *server) schema() *graphql.Schema {
builder := schemabuilder.NewSchema()
s.registerQuery(builder)
s.registerMutation(builder)
s.registerPost(builder)
return builder.MustBuild()
}
func main() {
server := &server{
posts: []post{
{Title: "first post!", Body: "I was here first!", CreatedAt: time.Now()},
{Title: "graphql", Body: "did you hear about Thunder?", CreatedAt: time.Now()},
},
}
schema := server.schema()
introspection.AddIntrospectionToSchema(schema)
http.Handle("/graphql", graphql.Handler(schema))
http.Handle("/graphiql/", http.StripPrefix("/graphiql/", graphiql.Handler()))
http.ListenAndServe(":3030", nil)
}
o publicar struct é o protótipo para o esquema GraphQL, e o servidor struct é a instância do servidor. o registrarConsulta, registrarMutaçãoe registrarPost métodos são funções de solução para consultas, mutações e armazenamento de dados.
o a Principal função começa com o servidor GraphQL na porta 3030 e o editor GraphQL.
Você pode consultar APIs GraphQL em Go com pacotes integrados
O GraphQL é fundamentado em HTTP e você pode consumir APIs do GraphQL com o built-in http package e outros pacotes semelhantes às APIs RESTful. Há também pacotes no ecossistema do Go que permitem consumir APIs GraphQL rapidamente.
Barnabé Ferreira