Há algumas semanas, mencionei que estava aprendendo sobre o GraphQL, cada vez mais popular, e como ele pode substituir a API RESTful comum. Em minha exemplo anteriorNa seção "Como criar um aplicativo GraphQL", vimos como criar um aplicativo GraphQL usando o Node.js e um Couchbase Banco de dados NoSQL. No entanto, sou tão fã da linguagem de programação Go quanto do Node.js.
Veremos como criar um aplicativo com a Golang que pode criar e consultar dados usando Consultas GraphQL em vez de vários endpoints de API RESTful.
Se você não estiver familiarizado com o GraphQL, ele funciona passando consultas de um front-end para o back-end e recebendo de volta apenas os dados que você solicitou, independentemente de sua origem ou complexidade, em vez de consumir dados de vários endpoints de API potencialmente não relacionados. Isso reduz suas solicitações e sua carga de dados, mantendo as coisas rápidas e eficientes.
Introdução ao GraphQL e à Golang
Como em uma API RESTful, a maior parte de um aplicativo GraphQL consistirá na configuração. No entanto, menos de um aplicativo GraphQL dependerá de planejamento, o que é diferente de uma API RESTful, que exige um planejamento pesado para permanecer fácil de usar.
Precisamos instalar uma dependência do pacote GraphQL para o Golang antes de prosseguirmos. Na linha de comando, execute o seguinte:
|
1 |
ir obter github.com/graphql-ir/graphql |
Com nossa dependência disponível, crie um novo projeto em seu $GOPATH. Dentro desse projeto, crie um arquivo chamado main.go e incluir o seguinte, que será nossa base de aplicativos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
pacote principal importação ( "encoding/json" "fmt" "log" "net/http" "github.com/graphql-go/graphql" ) tipo Conta estrutura { ID string `json:"id,omitempty"` Nome próprio string `json:"firstname"` Sobrenome string `json:"lastname" (sobrenome)` Tipo string `json:"tipo"` } tipo Blog estrutura { ID string `json:"id,omitempty"` Conta string `json:"account" (conta)` Título string `json:"título"` Conteúdo string `json:"content" (conteúdo)` Tipo string `json:"tipo"` } func principal() { fmt.Println("Iniciando o aplicativo...") accountType := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Conta", Campos: graphql.Campos{}, }) blogType := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Blog", Campos: graphql.Campos{}, }) rootQuery := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Consulta", Campos: graphql.Campos{}, }) rootMutation := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "RootMutation", Campos: graphql.Campos{}, }) esquema, _ := graphql.Novo esquema(graphql.SchemaConfig{ Consulta: rootQuery, Mutação: rootMutation, }) http.HandleFunc("/graphql", func(w http.Escritor de respostas, r *http.Solicitação) { resultado := graphql.Fazer(graphql.Parâmetros{ Esquema: esquema, RequestString: r.URL.Consulta().Obter("query" (consulta)), }) json.Novo codificador(w).Codificar(resultado) }) http.Ouvir e servir(":8080", nulo) } |
Nosso plano é criar um aplicativo que possa criar e consultar contas, bem como criar e consultar entradas de blog para qualquer conta específica. O modelo de dados do nosso aplicativo é definido pelo Conta e a estrutura Blog estrutura. Esse modelo de dados ajudará a alimentar nosso modelo de dados de banco de dados, bem como nosso modelo de dados GraphQL.
Quando se trata da configuração do GraphQL, você perceberá que há alguns objetos criados. O objeto accountType e o blogType representam o modelo de dados GraphQL que será criado em torno das estruturas Go. Eles ainda não estão configurados, mas serão. O rootQuery será o conjunto de consultas que podemos executar e o rootMutation será qualquer mutação de alteração de dados que possa ser executada. Com o GraphQL, você não está limitado apenas à leitura de dados.
O esquema GraphQL nos permite definir o que são consultas e o que são mutações. Isso é necessário para quando desejamos consumir consultas. Mesmo que não estejamos criando uma API RESTful, ainda precisamos de um endpoint HTTP. Esse único /graphql tratará de todas as consultas e mutações e é alimentado pelo esquema.
Antes de conectar o banco de dados, podemos definir nosso esquema GraphQL:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
accountType := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Conta", Campos: graphql.Campos{ "id": &graphql.Campo{ Tipo: graphql.Cordas, }, "firstname": &graphql.Campo{ Tipo: graphql.Cordas, }, "lastname" (sobrenome): &graphql.Campo{ Tipo: graphql.Cordas, }, }, }) blogType := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Blog", Campos: graphql.Campos{ "id": &graphql.Campo{ Tipo: graphql.Cordas, }, "account" (conta): &graphql.Campo{ Tipo: graphql.Cordas, }, "título": &graphql.Campo{ Tipo: graphql.Cordas, }, "content" (conteúdo): &graphql.Campo{ Tipo: graphql.Cordas, }, }, }) |
Observe que estamos definindo apenas os nomes das propriedades e o tipo de dados correspondente. Eu lhe disse que seria muito semelhante à forma como definimos as estruturas de dados em Go.
Agora vamos nos concentrar em carregar nosso esquema com dados do Couchbase Server.
Consulta de dados de um banco de dados NoSQL com GraphQL
Até o momento, não fizemos nenhuma preparação do banco de dados. O objetivo deste tutorial não é configurar o Couchbase. Você precisará do Couchbase Server disponível com suporte a N1QL, um Bucket, alguns índices e uma conta de controle de acesso baseada em função para o aplicativo.
Na linha de comando, execute as seguintes linhas para obter nossos pacotes de banco de dados:
|
1 2 |
ir obter github.com/satori/ir.uuid ir obter gopkg.em/couchbase/gocb.v1 |
Os comandos acima nos darão um pacote para criar valores UUID para chaves de documentos, bem como o Couchbase Go SDK.
Ignorando tudo o que já fizemos com nosso main.go dê uma olhada no código a seguir e encaixe-o no que você tem, onde fizer sentido:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
pacote principal importação ( "encoding/json" "fmt" "log" "net/http" "github.com/graphql-go/graphql" uuid "github.com/satori/go.uuid" gocb "gopkg.in/couchbase/gocb.v1" ) var balde *gocb.Balde func principal() { fmt.Println("Iniciando o aplicativo...") agrupamento, erro := gocb.Conectar("couchbase://localhost") se erro != nulo { registro.Fatal(erro) } agrupamento.Autenticar(gocb.PasswordAuthenticator{Nome de usuário: "exemplo", Senha: "123456"}) balde, erro = agrupamento.OpenBucket("exemplo", "") se erro != nulo { registro.Fatal(erro) } } |
Observe que definimos um Bucket que usaremos ao interagir com o banco de dados. Estamos nos conectando a um cluster do Couchbase no principal autenticação com uma conta RBAC e abertura de um Bucket, todos os quais devem ter sido definidos antes de iniciar este tutorial.
Vamos supor que você já tenha dados em seu banco de dados. Vamos começar tentando consultar os dados. Lembra-se do seguinte trecho de código que foi adicionado anteriormente?
|
1 2 3 4 |
rootQuery := graphql.Novo objeto(graphql.ObjectConfig{ Nome: "Consulta", Campos: graphql.Campos{ }, }) |
Cada campo existirá como um campo no Campos propriedade. Digamos que queremos obter todas as contas do nosso banco de dados.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
"contas": &graphql.Campo{ Tipo: graphql.Nova lista(accountType), Resolver: func(p graphql.ResolveParams) (interface{}, erro) { consulta := gocb.NewN1qlQuery("SELECT META(account).id, account.* FROM example AS account WHERE account.type = 'account'") linhas, erro := balde.ExecutarN1qlQuery(consulta, nulo) se erro != nulo { retorno nulo, erro } var contas []Conta var fila Conta para linhas.Próximo(&fila) { contas = anexar(contas, fila) } retorno contas, nulo }, }, |
No código acima, estamos criando um campo GraphQL chamado contas que retornará uma lista de accountType quando executado. O Resolver é a função que faz o trabalho pesado. Opcionalmente, podemos passar parâmetros de consulta, mas para esse campo específico não estamos passando. Ao tentar consultar as contas, estamos criando uma consulta N1QL que retorna todas as propriedades e resultados possíveis. A consulta GraphQL determinará quais dessas propriedades e resultados serão enviados ao cliente.
Veja a seguinte consulta de front-end que pode ser executada:
|
1 2 3 4 5 6 |
{ contas { id, primeiro nome } } |
Embora pudéssemos obter o id, primeiro nomee sobrenomeestamos optando por obter apenas o id e primeiro nome de nossos resultados. Para realmente executar a consulta, emitiríamos uma instrução cURL como esta:
|
1 |
enrolar -g 'http://localhost:8080/graphql?query={accounts{id,firstname}}' |
Lembre-se de que nossa consulta GraphQL é enviada para visualizar os parâmetros de consulta em nosso endpoint de API.
Vamos dar uma olhada em outra possível consulta GraphQL. Digamos que queiramos consultar uma conta específica, não todas as contas. Poderíamos criar um campo como o seguinte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
"account" (conta): &graphql.Campo{ Tipo: accountType, Args: graphql.FieldConfigArgument{ "id": &graphql.ArgumentConfig{ Tipo: graphql.NovoNãoNulo(graphql.Cordas), }, }, Resolver: func(parâmetros graphql.ResolveParams) (interface{}, erro) { var conta Conta conta.ID = parâmetros.Args["id"].(string) _, erro := balde.Obter(conta.ID, &conta) se erro != nulo { retorno nulo, erro } retorno conta, nulo }, }, |
Esse campo, quando consultado, retornará um único accountTypemas há argumentos que podem ser passados. Estamos exigindo que um id esteja presente e estamos exigindo que seja uma string. Na seção Resolver, podemos obter o id e usá-lo para obter um documento NoSQL pela chave do documento. O resultado é retornado e a consulta GraphQL determina quais propriedades são enviadas de volta ao cliente.
Veja a seguinte consulta:
|
1 2 3 4 5 6 |
{ conta(id:"2345345435") { primeiro nome, sobrenome } } |
Na consulta acima, passamos um ID e optamos por retornar apenas o primeiro nome e sobrenome dos resultados. Para executar de fato essa consulta, podemos emitir uma instrução cURL como a seguinte:
|
1 |
enrolar -g 'http://localhost:8080/graphql?query={account(id: "2345345435"){firstname,lastname}}' |
Agora, digamos que queremos retornar todos os blogs de uma determinada conta de usuário. As etapas serão semelhantes às que vimos quando consultamos uma conta específica. O seguinte existiria como um campo em nosso rootQuery:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
"blogs": &graphql.Campo{ Tipo: graphql.Nova lista(blogType), Args: graphql.FieldConfigArgument{ "account" (conta): &graphql.ArgumentConfig{ Tipo: graphql.NovoNãoNulo(graphql.Cordas), }, }, Resolver: func(parâmetros graphql.ResolveParams) (interface{}, erro) { conta := parâmetros.Args["account" (conta)].(string) consulta := gocb.NewN1qlQuery("SELECT META(blog).id, blog.* FROM example AS blog WHERE blog.type = 'blog' AND blog.account = $1") var n1qlParams []interface{} n1qlParams = anexar(n1qlParams, conta) linhas, erro := balde.ExecutarN1qlQuery(consulta, n1qlParams) se erro != nulo { retorno nulo, erro } var blogs []Blog var fila Blog para linhas.Próximo(&fila) { blogs = anexar(blogs, fila) } retorno blogs, nulo }, }, |
O resultado será uma lista de blogType e estamos esperando um conta a ser passado no formato de cadeia de caracteres. Dentro do Resolver podemos obter a função conta e usá-lo em uma consulta N1QL parametrizada. A consulta retornará todas as entradas de blog somente para uma determinada conta com base no valor conta valor.
A consulta para obter todos os blogs pode ser parecida com a seguinte:
|
1 2 3 4 5 6 |
{ blogs(conta:"2345345435") { id, título } } |
O exemplo acima é bastante semelhante ao que vimos ao consultar uma conta específica. Estamos esperando uma variável e optamos por retornar apenas a variável id e o título propriedades.
Quer ver uma consulta bem legal com base no que temos até agora? Dê uma olhada na consulta a seguir:
|
1 2 3 4 5 6 7 8 9 10 |
{ conta(id:"2345345435") { primeiro nome, sobrenome } blogs(conta:"2345345435") { título, conteúdo } } |
No exemplo acima, estamos fazendo uma única solicitação. É uma única consulta, mas estamos solicitando dados de conta e dados de blog de uma determinada conta. Se tivéssemos feito isso com uma API RESTful, teríamos feito várias solicitações ao nosso servidor e teríamos feito possíveis mutações no nível do aplicativo.
O comando cURL teria a seguinte aparência:
|
1 |
enrolar -g 'http://localhost:8080/graphql?query={account(id: "2345345435"){firstname,lastname}blogs(account: "2345345435"){title,content}}' |
Até agora, fizemos apenas consultas de leitura. E se quisermos fazer uma mutação em que criamos ou alteramos dados?
Vamos dar uma olhada nas mutações de dados com o GraphQL.
Em vez de trabalhar no rootQueryVamos trabalhar no rootMutation. Para os campos, adicione o seguinte:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
"createAccount": &graphql.Campo{ Tipo: accountType, Args: graphql.FieldConfigArgument{ "firstname": &graphql.ArgumentConfig{ Tipo: graphql.NovoNãoNulo(graphql.Cordas), }, "lastname" (sobrenome): &graphql.ArgumentConfig{ Tipo: graphql.NovoNãoNulo(graphql.Cordas), }, }, Resolver: func(parâmetros graphql.ResolveParams) (interface{}, erro) { var conta Conta conta.Nome próprio = parâmetros.Args["firstname"].(string) conta.Sobrenome = parâmetros.Args["lastname" (sobrenome)].(string) conta.Tipo = "account" (conta) id, _ := uuid.NovoV4() _, erro := balde.Inserir(id.Cordas(), &conta, 0) se erro != nulo { retorno nulo, erro } conta.ID = id.Cordas() retorno conta, nulo }, }, |
Observe que estamos retornando um accountType e que estamos esperando que dois parâmetros sejam passados com a nossa consulta. No entanto, a estratégia realmente não é diferente.
No Resolver estamos obtendo nossos parâmetros e usando-os para criar uma nova conta no banco de dados. Como isso está vinculado ao nosso esquema como uma mutação, estamos consultando de forma diferente.
Primeiro, aqui está a consulta que queremos executar:
|
1 2 3 4 5 6 7 |
mutação+_ { createAccount(primeiro nome:"Matt",sobrenome:"Groves") { id, primeiro nome, sobrenome } } |
Observe que estamos prefixando com a palavra mutação. No cURL, ele teria a seguinte aparência:
|
1 |
enrolar -g 'http://localhost:8080/graphql?query=mutation+_{createAccount(firstname: "Matt",lastname: "Groves"){id,firstname,lastname}}' |
Agora eu poderia continuar criando campos que fazem consultas ou mutações, mas as etapas são as mesmas. Deixo para sua imaginação continuar contribuindo para essa ideia específica de aplicativo.
Conclusão
Você acabou de ver como usar GraphQL para consultar dados em um aplicativo Golang que usa um Banco de dados NoSQL. O GraphQL é muito útil se você quiser permitir que o usuário defina os dados que deseja em uma única solicitação, em vez de criar incansavelmente vários pontos de extremidade de API RESTful que o usuário deve acompanhar. É importante observar que o GraphQL não é um substituto quando se trata de seu aplicativo consultar o banco de dados. Você ainda precisará criar consultas N1QL adequadas em Couchbase. O GraphQL opera somente no nível do cliente.
Para obter mais informações sobre o uso de Go com o Couchbase, consulte a seção Portal do desenvolvedor do Couchbase.
