{"id":2854,"date":"2017-02-28T08:41:20","date_gmt":"2017-02-28T16:41:20","guid":{"rendered":"https:\/\/www.couchbase.com\/blog\/?p=2854"},"modified":"2025-06-13T21:40:21","modified_gmt":"2025-06-14T04:40:21","slug":"graphql-server-node-couchbase-ottoman-spatial-view","status":"publish","type":"post","link":"https:\/\/www.couchbase.com\/blog\/pt\/graphql-server-node-couchbase-ottoman-spatial-view\/","title":{"rendered":"Servidor Graphql com node e couchbase, ottoman e visualiza\u00e7\u00e3o espacial"},"content":{"rendered":"

Jos\u00e9 Navarro<\/span><\/a> \u00e9 um desenvolvedor full stack na FAMOCO em Bruxelas, B\u00e9lgica. Ele tem trabalhado nos \u00faltimos 3 anos como desenvolvedor web desenvolvedor<\/a> com Node.js, Java, AngularJS e ReactJS, e tem grande interesse em desenvolvimento web e tecnologias m\u00f3veis.<\/em><\/p>\n

Vamos desenvolver um Graphql<\/a><\/u>\u00a0servidor em nodejs com express. Graphql \u00e9 uma linguagem de consulta para APIs, foi desenvolvida pelo Facebook e lan\u00e7ada em 2015. Ela foi projetada para criar aplicativos de clientes fornecendo uma sintaxe e um sistema intuitivos e flex\u00edveis para descrever seus requisitos de dados e intera\u00e7\u00f5es. Uma das maiores diferen\u00e7as em rela\u00e7\u00e3o \u00e0s APIs REST \u00e9 que voc\u00ea tem apenas um ponto de extremidade de entrada para todos os recursos, em vez de um ponto de extremidade para cada recurso; e com o graphql voc\u00ea especifica os atributos que deseja para cada solicita\u00e7\u00e3o, em vez de receber o que quer que o servi\u00e7o da API REST retorne, para que possamos ter certeza de que temos todos os dados de que precisamos e reduzir o tamanho de nossas solicita\u00e7\u00f5es.<\/p>\n

O Facebook o utiliza h\u00e1 alguns anos em seu aplicativo m\u00f3vel, por exemplo, no aplicativo para iOS, e a vers\u00e3o antiga do aplicativo m\u00f3vel ainda funciona sem problemas porque o graphql n\u00e3o mudou, porque \u00e9 um ponto de extremidade com o mesmo esquema, o que provavelmente n\u00e3o seria poss\u00edvel com as APIs REST, porque quando voc\u00ea lan\u00e7a uma nova vers\u00e3o da API, seu ponto de extremidade provavelmente vai mudar, de modo que os clientes precisam se adaptar ao novo ponto de extremidade e aos dados. Al\u00e9m disso Github<\/a><\/u>\u00a0abrir seu servidor graphql, para que os usu\u00e1rios possam consultar seus servi\u00e7os usando graphql, em vez dos servi\u00e7os de APIs REST...<\/p>\n

Com o servidor, vamos consultar e criar Locais<\/strong>. Para armazenar os dados, usaremos o couchbase e as exibi\u00e7\u00f5es espaciais para consultar os locais por sua localiza\u00e7\u00e3o geogr\u00e1fica. Escrevi um artigo anterior postagem<\/a><\/u>\u00a0sobre o node e o couchbase, portanto, vou pular a configura\u00e7\u00e3o do banco de dados que escrevi na postagem anterior.<\/p>\n

Requisitos<\/h2>\n

Voc\u00ea precisa ter instalado em seu computador:<\/p>\n

- nodejs<\/p>\n

- servidor couchbase<\/p>\n

Voc\u00ea pode encontrar o c\u00f3digo na se\u00e7\u00e3o reposit\u00f3rio do github<\/a><\/u>.<\/p>\n

Vis\u00e3o espacial<\/h2>\n

Antes de tudo, precisamos criar a visualiza\u00e7\u00e3o espacial. Vamos para a p\u00e1gina de administra\u00e7\u00e3o, no meu caso https:\/\/localhost:8091\/<\/a><\/u>\u00a0e fa\u00e7a login com meu usu\u00e1rio e senha. Em seguida, clique em Compartimentos de dados<\/strong>\u00a0e criar um bucket, que chamei de graphql<\/em>. Depois disso, clicamos em Ver<\/strong>e, em seguida, clicamos em Criar visualiza\u00e7\u00e3o espacial do desenvolvimento<\/strong>e digitamos os valores.<\/p>\n

\"Create<\/p>\n

Eu usei lugar_por_localiza\u00e7\u00e3o<\/em>\u00a0em ambos Nome do documento de design<\/strong>\u00a0e Ver nome<\/strong>. Agora clique em editar<\/strong>e adicione o seguinte c\u00f3digo<\/p>\n


\nfunction (doc) {<\/code><\/p>\n

Se (doc._type === 'Place' && doc.location) {<\/p>\n

emit([{<\/p>\n

\"type\": \"Ponto\",<\/p>\n

\"coordenadas\": [doc.location.lon, doc.location.lat]<\/p>\n

}], doc);<\/p>\n

}<\/p>\n

}
\ne clique em Salvar<\/strong>.<\/p>\n

Aqui voc\u00ea tamb\u00e9m pode testar a visualiza\u00e7\u00e3o com os documentos no balde.<\/p>\n

Local Modelo<\/h2>\n

Para nossos locais, vamos armazenar o nome do local e uma descri\u00e7\u00e3o como string.<\/p>\n

Como queremos usar o SpatialView<\/a> que Couchbase<\/a> fornece, vamos armazenar a localiza\u00e7\u00e3o do local em um objeto chamado *location*, no qual armazenaremos a latitude e a longitude.<\/p>\n

Al\u00e9m disso, definiremos por padr\u00e3o a data de cria\u00e7\u00e3o quando adicionarmos o local.<\/p>\n


\nconst PlaceModel = ottoman.model('Place', {<\/code><\/p>\n

nome: 'string',<\/p>\n

descri\u00e7\u00e3o: 'string',<\/p>\n

localiza\u00e7\u00e3o: {<\/p>\n

lat: 'number',<\/p>\n

lon: 'number'<\/p>\n

},<\/p>\n

criado: {<\/p>\n

tipo: 'Date',<\/p>\n

padr\u00e3o: Date.now<\/p>\n

}<\/p>\n

});
\nPara a consulta espacial, vamos definir uma fun\u00e7\u00e3o que executar\u00e1 uma consulta espacial. Para isso, vamos criar uma consulta espacial usando o pacote couchbase.<\/p>\n


\nconst queryByLocation = (bbox = [0, 0, 0, 0], next) => {<\/code><\/p>\n

const query = couchbase.SpatialQuery.from('dev_place_by_location', 'place_by_location').bbox(bbox);<\/p>\n

bucket.query(query, next);<\/p>\n

}
\nNa fun\u00e7\u00e3o *from*, precisamos fornecer o *nome do documento de design* e o *nome da visualiza\u00e7\u00e3o*. Em seguida, na bbox (caixa delimitadora), precisamos fornecer a matriz de 4 pontos flutuantes **[ min Longitude , min Latitude , max Longitude , max Latitude ]**.<\/p>\n

A \u00faltima etapa \u00e9 executar a consulta no bucket.<\/p>\n

Servidor Graphql<\/h2>\n

Vamos usar um servidor express e o pacote express-graphql.<\/p>\n

Importamos o esquema do nosso servidor graphql que definiremos mais tarde.<\/p>\n


\nconst express = require('express');<\/code><\/p>\n

const graphqlHTTP = require('express-graphql');<\/p>\n

const PORT = process.env.PORT || 5000;<\/p>\n

const schema = require('.\/schemas');<\/p>\n

const app = express();<\/p>\n

app.use('\/graphql', graphqlHTTP({<\/p>\n

esquema: esquema,<\/p>\n

graphiql: true,<\/p>\n

}));<\/p>\n

\/\/ iniciar o servidor<\/p>\n

const server = app.listen(PORT, () => {<\/p>\n

console.log(`Server started at ${ server.address().port }`);<\/p>\n

});
\nNo servidor graphql, usaremos a rota *\/graphql*. E vamos definir alguma op\u00e7\u00e3o, como graphiql, que nos fornecer\u00e1 uma interface gr\u00e1fica para executar consultas.<\/p>\n

A \u00faltima etapa \u00e9 iniciar nosso servidor expresso.<\/p>\n

Esquemas Graphql<\/h2>\n

As consultas e muta\u00e7\u00f5es do Graphql dependem dos esquemas que definimos. Portanto, temos de criar um esquema para o nosso objeto Place.<\/p>\n

Primeiro, vamos definir um esquema para Localiza\u00e7\u00e3o<\/strong>.<\/p>\n


\nconst {<\/code><\/p>\n

GraphQLObjectType,<\/p>\n

GraphQLFloat,<\/p>\n

GraphQLNonNull,<\/p>\n

} = require('graphql');<\/p>\n

const LocationSchema = new GraphQLObjectType({<\/p>\n

nome: 'Location',<\/p>\n

description: 'Geographical location',<\/p>\n

campos: {<\/p>\n

lat: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

descri\u00e7\u00e3o: 'Latitude',<\/p>\n

},<\/p>\n

lon: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

descri\u00e7\u00e3o: 'Longitude',<\/p>\n

},<\/p>\n

}<\/p>\n

});<\/p>\n

module.exports = LocationSchema;<\/p>\n

Precisamos importar os tipos de graphql<\/em>\u00a0pacote. Em nosso esquema, podemos definir um nome e uma descri\u00e7\u00e3o. Esses campos s\u00e3o \u00fateis para documentar nossas consultas, para que o usu\u00e1rio possa entender o que o campo significa.<\/p>\n

Ent\u00e3o temos que definir campos<\/em>onde especificaremos os campos dentro de nosso esquema; nesse caso, definimos lat<\/em>\u00a0e solit\u00e1rio<\/em>. Em cada campo, temos que especificar o tipo; nesse caso, esses campos s\u00e3o valores float e s\u00e3o obrigat\u00f3rios, portanto, usamos GraphQLNonNull<\/em>\u00a0 e o tipo GraphQLFloat<\/em>. Adicionamos uma descri\u00e7\u00e3o para que possamos saber o que eles significam.<\/p>\n

Agora vamos definir o esquema Local<\/strong>.<\/p>\n

Aqui, vamos importar os tipos de graphql<\/em>\u00a0e o esquema Localiza\u00e7\u00e3o<\/em>\u00a0que definimos.<\/p>\n


\nconst {<\/code><\/p>\n

GraphQLObjectType,<\/p>\n

GraphQLString,<\/p>\n

GraphQLNonNull,<\/p>\n

} = require('graphql');<\/p>\n

const LocationSchema = require('.\/location');<\/p>\n

const PlaceSchema = new GraphQLObjectType({<\/p>\n

nome: 'Place',<\/p>\n

description: 'Descri\u00e7\u00e3o do local',<\/p>\n

campos: {<\/p>\n

id: {<\/p>\n

Tipo: GraphQLString,<\/p>\n

resolve(place) {<\/p>\n

return place._id;<\/p>\n

}<\/p>\n

},<\/p>\n

nome: {<\/p>\n

Tipo: GraphQLString,<\/p>\n

},<\/p>\n

descri\u00e7\u00e3o:{<\/p>\n

Tipo: GraphQLString,<\/p>\n

},<\/p>\n

localiza\u00e7\u00e3o: {<\/p>\n

Tipo: LocationSchema,<\/p>\n

},<\/p>\n

criado: {<\/p>\n

Tipo: GraphQLString,<\/p>\n

}<\/p>\n

}<\/p>\n

});<\/p>\n

module.exports = PlaceSchema;<\/p>\n

Estamos combinando os campos do modelo, portanto, n\u00e3o precisamos fornecer a fun\u00e7\u00e3o de resolu\u00e7\u00e3o. Somente para o campo id<\/em>porque o couchbase retorna o valor no campo _id<\/strong>.<\/p>\n

Consulta Graphql<\/h2>\n

A consulta \u00e9 a maneira pela qual recuperamos dados para o servidor.<\/p>\n

O objeto de consulta tamb\u00e9m \u00e9 um esquema, como os anteriores. Nesse caso, os campos s\u00e3o as consultas que permitimos que o usu\u00e1rio execute. Vamos definir tr\u00eas tipos de consulta.<\/p>\n

Todos os lugares<\/h3>\n

Nessa consulta, vamos consultar todos os locais no banco de dados e vamos orden\u00e1-los pelo campo criado, para que retornemos primeiro os locais mais novos.<\/p>\n

Como vamos retornar uma matriz de Places, atribu\u00edmos a tipo<\/strong>\u00a0o tipo GraphQLList<\/em>\u00a0e fornecemos o Esquema de local<\/em><\/p>\n


\n...<\/code><\/p>\n

const PlaceSchema = require('.\/place');<\/p>\n

const Place = require('..\/models\/place');<\/p>\n

…<\/p>\n

allPlaces: {<\/p>\n

type: new GraphQLList(PlaceSchema),<\/p>\n

descri\u00e7\u00e3o: 'Query for all places',<\/p>\n

resolve(root, args) {<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

Place.find({}, {<\/p>\n

sort: {<\/p>\n

criado: -1<\/p>\n

},<\/p>\n

}, (err, places) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolver(lugares);<\/p>\n

})<\/p>\n

});<\/p>\n

}<\/p>\n

}<\/p>\n

Tamb\u00e9m adicionamos uma descri\u00e7\u00e3o, esse campo \u00e9 opcional.<\/p>\n

O \u00faltimo par\u00e2metro \u00e9 uma fun\u00e7\u00e3o, ou seja, a fun\u00e7\u00e3o resolve, que especificar\u00e1 como recuperaremos os dados do nosso banco de dados. Como nossas chamadas para o banco de dados s\u00e3o ass\u00edncronas, retornaremos uma promessa que usar\u00e1 o modelo Place que definimos com o ottoman. Com o modelo, usamos find para consultar os documentos e passamos como primeiro par\u00e2metro um objeto vazio, porque queremos consultar todos os documentos; o segundo par\u00e2metro s\u00e3o as op\u00e7\u00f5es da nossa consulta; nesse caso, vamos ordenar pelo campo criado<\/em>\u00a0em ordem decrescente. Por fim, fornecemos a fun\u00e7\u00e3o de retorno de chamada que resolver\u00e1 a promessa com os valores ou a rejeitar\u00e1 em caso de erro.<\/p>\n

Locais<\/h3>\n

Nessa consulta, vamos consultar usando a visualiza\u00e7\u00e3o Spatial, portanto, temos que passar os pontos bbox no par\u00e2metro da consulta.<\/p>\n


\n...<\/code><\/p>\n

const queryByLocation = require('..\/models\/place').queryByLocation;<\/p>\n

…<\/p>\n

Locais: {<\/p>\n

type: new GraphQLList(PlaceSchema),<\/p>\n

descri\u00e7\u00e3o: 'Query for all places inside the boundary box',<\/p>\n

args: {<\/p>\n

minLon: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

description: 'Min Longitude of the boundary box' (Longitude m\u00ednima da caixa de limite),<\/p>\n

},<\/p>\n

maxLon: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

descri\u00e7\u00e3o: \"Max Longitude of the boundary box\" (Longitude m\u00e1xima da caixa de limite),<\/p>\n

},<\/p>\n

minLat: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

descri\u00e7\u00e3o: 'Latitude m\u00ednima da caixa de limite',<\/p>\n

},<\/p>\n

maxLat: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

descri\u00e7\u00e3o: 'Latitude m\u00e1xima da caixa de limite',<\/p>\n

},<\/p>\n

},<\/p>\n

resolve(root, args) {<\/p>\n

\/\/ bbox = [ min Longitude , min Latitude , max Longitude , max Latitude ]<\/p>\n

const bbox = [<\/p>\n

args.minLon,<\/p>\n

args.minLat,<\/p>\n

args.maxLon,<\/p>\n

args.maxLat,<\/p>\n

];<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

queryByLocation(bbox, (err, places) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolve(places.map((place) => place.value));<\/p>\n

})<\/p>\n

});<\/p>\n

}<\/p>\n

}<\/p>\n

Primeiro, importamos a fun\u00e7\u00e3o que definimos para realizar a consulta espacial.<\/p>\n

Como na consulta anterior, definimos o tipo como uma matriz de locais e adicionamos uma descri\u00e7\u00e3o.<\/p>\n

Nessa consulta, precisamos de algum par\u00e2metro, ent\u00e3o definimos os args, que se referem ao par\u00e2metro; cada valor dentro de argumentos<\/em>\u00a0correspondem aos par\u00e2metros; nesse caso, definimos 4, minLon, maxLon, minLat, maxLat<\/strong>\u00a0e, para todos eles, vamos definir o tipo como obrigat\u00f3rio e floats.<\/p>\n

Nesse caso, a fun\u00e7\u00e3o de resolu\u00e7\u00e3o tamb\u00e9m \u00e9 uma promessa. Primeiro, criamos a matriz bbox para passar a fun\u00e7\u00e3o queryByLocation<\/em>. Em caso de erro, rejeitaremos a promessa com um erro; em caso de sucesso, precisaremos mapear o objeto do banco de dados, pois a visualiza\u00e7\u00e3o espacial retorna o ponto geogr\u00e1fico e o valor, e quando estivermos retornando o documento completo, isso mudar\u00e1 se definirmos uma visualiza\u00e7\u00e3o espacial diferente.<\/p>\n

Local<\/h3>\n

A \u00faltima consulta que vamos definir \u00e9 a que consulta um local pelo seu ID.<\/p>\n


\nLocal: {<\/code><\/p>\n

Tipo: PlaceSchema,<\/p>\n

descri\u00e7\u00e3o: \"Consulta de um local pelo ID do local\",<\/p>\n

args: {<\/p>\n

id: {<\/p>\n

type: new GraphQLNonNull(GraphQLString),<\/p>\n

descri\u00e7\u00e3o: 'Place id',<\/p>\n

}<\/p>\n

},<\/p>\n

resolve(root, args) {<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

Place.getById(args.id, (err, place) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolver(lugar);<\/p>\n

});<\/p>\n

});<\/p>\n

}
\nNesse caso, o tipo \u00e9 o Esquema de local<\/em>nos args, s\u00f3 precisamos definir o id<\/strong>\u00a0e o definimos como string e obrigat\u00f3rio.<\/p>\n

A fun\u00e7\u00e3o resolve, mais uma vez, \u00e9 uma promessa; nesse caso, usaremos a fun\u00e7\u00e3o queryById<\/em>\u00a0do modelo, e passamos o id<\/em>\u00a0do objeto args.<\/p>\n

Muta\u00e7\u00e3o do Graphql<\/h2>\n

Com as muta\u00e7\u00f5es, podemos modificar os dados em nosso servidor. Assim como a consulta, os objetos de muta\u00e7\u00e3o s\u00e3o esquemas. Portanto, temos que definir os mesmos campos que os esquemas anteriores.<\/p>\n

Quando realizamos a consulta de muta\u00e7\u00e3o, fornecemos os valores entre par\u00eanteses e, assim como as consultas, fornecemos os valores que queremos recuperar do objeto modificado.<\/p>\n

Aqui, realizaremos a cria\u00e7\u00e3o, a atualiza\u00e7\u00e3o e a exclus\u00e3o de Locais.<\/p>\n

createPlace<\/h3>\n

Nesta muta\u00e7\u00e3o, vamos criar um novo local.<\/p>\n

No tipo do esquema, vamos defini-lo como Esquema de local<\/em>porque vamos retornar o local criado.<\/p>\n


\ncreatePlace: {<\/code><\/p>\n

Tipo: PlaceSchema,<\/p>\n

descri\u00e7\u00e3o: 'Create a place',<\/p>\n

args: {<\/p>\n

nome: {<\/p>\n

type: new GraphQLNonNull(GraphQLString),<\/p>\n

description: 'Nome do local',<\/p>\n

},<\/p>\n

descri\u00e7\u00e3o: {<\/p>\n

type: new GraphQLNonNull(GraphQLString),<\/p>\n

description: \"Descri\u00e7\u00e3o do local\",<\/p>\n

},<\/p>\n

latitude: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

description: 'Latitude do local',<\/p>\n

},<\/p>\n

longitude: {<\/p>\n

type: new GraphQLNonNull(GraphQLFloat),<\/p>\n

description: 'Longitude do local',<\/p>\n

}<\/p>\n

},<\/p>\n

resolve(source, args) {<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

const place = new Place({<\/p>\n

name: args.name,<\/p>\n

description: args.description,<\/p>\n

localiza\u00e7\u00e3o: {<\/p>\n

lat: args.latitude,<\/p>\n

lon: args.longitude,<\/p>\n

},<\/p>\n

});<\/p>\n

place.save((err) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolver(lugar);<\/p>\n

})<\/p>\n

});<\/p>\n

}<\/p>\n

}
\nComo nas consultas, definimos os argumentos com os valores necess\u00e1rios para criar um novo local. Nesse caso, exigimos que o nome e a descri\u00e7\u00e3o sejam strings e que a latitude e a longitude sejam floats; todos os campos ser\u00e3o obrigat\u00f3rios.<\/p>\n

Na fun\u00e7\u00e3o resolver, vamos retornar uma promessa. Dentro da promessa, vamos criar o local com os valores da consulta dentro de argumentos<\/em>. Em seguida, vamos realizar salvar<\/em>\u00a0no objeto do local. Por fim, no caso de um erro ao salvar o local, rejeitaremos a promessa com o erro ou resolveremos a promessa com os dados do local.<\/p>\n

updatePlace<\/h3>\n

Como no createPlace<\/em>\u00a0muta\u00e7\u00e3o, o updatePlace<\/em>\u00a0A muta\u00e7\u00e3o \u00e9 semelhante, as diferen\u00e7as s\u00e3o que, nesse caso, todos os valores nos args n\u00e3o s\u00e3o obrigat\u00f3rios e o campo id \u00e9 uma string obrigat\u00f3ria; e na fun\u00e7\u00e3o resolve, primeiro vamos procurar o objeto pelo par\u00e2metro id<\/em>Em seguida, verificamos os campos fornecidos pelo usu\u00e1rio e atualizamos o local e, por fim, salvamos e retornamos o novo objeto<\/p>\n


\nupdatePlace: {<\/code><\/p>\n

Tipo: PlaceSchema,<\/p>\n

descri\u00e7\u00e3o: \"Atualizar um local\",<\/p>\n

args: {<\/p>\n

id: {<\/p>\n

type: new GraphQLNonNull(GraphQLString),<\/p>\n

descri\u00e7\u00e3o: 'Id do local',<\/p>\n

},<\/p>\n

nome: {<\/p>\n

Tipo: GraphQLString,<\/p>\n

description: 'Nome do local',<\/p>\n

},<\/p>\n

descri\u00e7\u00e3o: {<\/p>\n

Tipo: GraphQLString,<\/p>\n

description: \"Descri\u00e7\u00e3o do local\",<\/p>\n

},<\/p>\n

latitude: {<\/p>\n

Tipo: GraphQLFloat,<\/p>\n

description: 'Latitude do local',<\/p>\n

},<\/p>\n

longitude: {<\/p>\n

Tipo: GraphQLFloat,<\/p>\n

description: 'Longitude do local',<\/p>\n

}<\/p>\n

},<\/p>\n

resolve(source, args) {<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

Place.getById(args.id, (err, place) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

} else {<\/p>\n

Se (args.name) {<\/p>\n

place.name = args.name;<\/p>\n

}<\/p>\n

Se (args.description) {<\/p>\n

place.name = args.name;<\/p>\n

}<\/p>\n

Se (args.latitude) {<\/p>\n

place.location.lat = args.latitude;<\/p>\n

}<\/p>\n

Se (args.longitude) {<\/p>\n

place.location.lon = args.longitude;<\/p>\n

}<\/p>\n

place.save((err) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolver(lugar);<\/p>\n

});<\/p>\n

}<\/p>\n

})<\/p>\n

});<\/p>\n

}<\/p>\n

}<\/p>\n

deletePlace<\/h3>\n

A \u00faltima muta\u00e7\u00e3o \u00e9 a exclus\u00e3o, na qual definimos um tipo de Esquema de local<\/em>porque vamos retornar o objeto que exclu\u00edmos.<\/p>\n

Nos args, s\u00f3 precisamos definir o id<\/em>\u00a0do local a ser exclu\u00eddo.<\/p>\n

Na fun\u00e7\u00e3o de resolu\u00e7\u00e3o, retornaremos uma Promise que procurar\u00e1 o local pelo ID e executar\u00e1 a remo\u00e7\u00e3o. Rejeitaremos a promessa caso o local n\u00e3o seja encontrado ou se houver um erro ao remov\u00ea-lo; ou resolveremos a promessa com os dados do local caso o removamos com \u00eaxito.<\/p>\n


\ndeletePlace: {<\/code><\/p>\n

Tipo: PlaceSchema,<\/p>\n

descri\u00e7\u00e3o: 'Delete a place',<\/p>\n

args: {<\/p>\n

id: {<\/p>\n

type: new GraphQLNonNull(GraphQLString),<\/p>\n

descri\u00e7\u00e3o: 'Id do local',<\/p>\n

},<\/p>\n

},<\/p>\n

resolve(source, args) {<\/p>\n

return new Promise((resolve, reject) => {<\/p>\n

Place.getById(args.id, (err, place) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

} else {<\/p>\n

place.remove((err) => {<\/p>\n

se (err) {<\/p>\n

reject(err);<\/p>\n

}<\/p>\n

resolver(lugar);<\/p>\n

});<\/p>\n

}<\/p>\n

})<\/p>\n

});<\/p>\n

}<\/p>\n

}<\/p>\n

Teste<\/h2>\n

Para testar nosso aplicativo, vamos usar o Graphiql, que permitimos em nosso servidor. Para isso, precisamos acessar https:\/\/localhost:5000\/graphql<\/p>\n

\"graphiql\"<\/p>\n

Nessa p\u00e1gina, podemos realizar as consultas e muta\u00e7\u00f5es que definimos anteriormente.<\/p>\n

Criar<\/h3>\n


\nmuta\u00e7\u00e3o {<\/code><\/p>\n

createPlace(<\/p>\n

nome: \"testplace\"<\/p>\n

descri\u00e7\u00e3o: \"testdescription\"<\/p>\n

latitude: 1,36<\/p>\n

longitude: 18,36<\/p>\n

)\u00a0{<\/p>\n

id<\/p>\n

}<\/p>\n

}<\/p>\n

\"mutation<\/p>\n

Atualiza\u00e7\u00e3o<\/h3>\n


\nmuta\u00e7\u00e3o {<\/code><\/p>\n

updatePlace(<\/p>\n

id: \u201c41133f98-18e8-4979-89e0-7af012b0e14f\u201d<\/p>\n

nome: \"updateplace\"<\/p>\n

descri\u00e7\u00e3o: \"updatedescription\"<\/p>\n

latitude: 2,36<\/p>\n

longitude: 15,96<\/p>\n

)\u00a0{<\/p>\n

id<\/p>\n

nome<\/p>\n

descri\u00e7\u00e3o<\/p>\n

}<\/p>\n

}<\/p>\n

\"mutation<\/p>\n

Excluir<\/h3>\n


\nmuta\u00e7\u00e3o {<\/code><\/p>\n

deletePlace(id: \"41133f98-18e8-4979-89e0-7af012b0e14f\") {<\/p>\n

id<\/p>\n

}<\/p>\n

}
\n\"mutation<\/p>\n

Consultar tudo<\/h3>\n


\nconsulta {<\/code><\/p>\n

allPlaces {<\/p>\n

id<\/p>\n

nome<\/p>\n

localiza\u00e7\u00e3o {<\/p>\n

lat<\/p>\n

solit\u00e1rio<\/p>\n

}<\/p>\n

}<\/p>\n

}<\/p>\n

\"query<\/p>\n

Consulta por caixa de limite<\/h3>\n


\nconsulta {<\/code><\/p>\n

Locais(<\/p>\n

minLon: 3<\/p>\n

maxLon: 5<\/p>\n

minLat: 49<\/p>\n

maxLat: 51<\/p>\n

)\u00a0{<\/p>\n

nome<\/p>\n

localiza\u00e7\u00e3o {<\/p>\n

lat<\/p>\n

solit\u00e1rio<\/p>\n

}<\/p>\n

}<\/p>\n

}
\n\"query<\/p>\n

Consultar um local por id<\/h3>\n


\n```<\/code><\/p>\n

muta\u00e7\u00e3o {<\/p>\n

deletePlace(id: \"41133f98-18e8-4979-89e0-7af012b0e14f\") {<\/p>\n

id<\/p>\n

}<\/p>\n

}<\/p>\n

“`
\n\"query<\/p>\n

Conclus\u00e3o<\/h2>\n

O Graphql \u00e9 uma boa linguagem de consulta que nos permite consultar apenas as informa\u00e7\u00f5es que definimos, de modo que podemos evitar a busca excessiva ou insuficiente e podemos ter certeza de que sempre teremos os dados.<\/p>\n

Em um servidor Graphql, os clientes usam apenas um \u00fanico ponto de extremidade, o que oculta a complexidade e a l\u00f3gica do back-end, de modo que o servidor pode se conectar a diferentes back-ends ou usar diferentes bancos de dados e, se eles mudarem, a l\u00f3gica dos clientes n\u00e3o precisar\u00e1 mudar porque o ponto de extremidade \u00e9 o mesmo.<\/p>\n

Tamb\u00e9m vimos como realizar uma consulta geogr\u00e1fica em nossos dados com o couchbase.<\/p>\n

Refer\u00eancias<\/h2>\n