O que é GraphQL?
GraphQL é uma linguagem de consulta open-source para APIs, inicialmente desenvolvida pelo Facebook em 2012 e lançada ao público em 2015. Ela oferece uma alternativa flexível e eficiente às tradicionais APIs REST, permitindo que os clientes solicitem apenas os dados específicos de que precisam, resolvendo problemas de sobrecarga e subcarga que muitas vezes ocorrem com as APIs REST.
Uma das razões para a crescente popularidade do GraphQL é sua natureza orientada ao cliente. Isso o torna particularmente adequado para aplicações modernas onde desempenho, escalabilidade e experiências de usuário contínuas são críticas. O GraphQL permite que os clientes combinem múltiplos recursos em uma única solicitação, reduzindo o tráfego de rede e tornando-se uma excelente solução para aplicativos móveis com largura de banda limitada ou necessidades complexas de front-end.
Grandes empresas como GitHub, Twitter, Indeed e Shopify adotaram GraphQL, destacando seu potencial para simplificar o desenvolvimento de APIs e melhorar as interações cliente-servidor.
Interface GraphQL
No GraphQL, uma Interface funciona de maneira semelhante às interfaces na programação orientada a objetos. É um tipo abstrato que define um conjunto de campos comuns que múltiplos tipos de objeto podem implementar. Isso garante que o cliente possa consultar esses campos comuns com confiança em diferentes tipos.
type Query {
findVehicles(): [Vehicle!]!
}
interface Vehicle {
id: ID!
name: String!
model: String
}
type Car implements Vehicle {
id: ID!
name: String!
model: String
# Specific to Car
fuelType: String!
}
type Bicycle implements Vehicle {
id: ID!
name: String!
model: String
# Specific to Bicycle
gearCount: Int!
isElectric: Boolean!
}
Consulta de cliente GraphQL:
query findVehicles() {
findVehicles() {
vehicle {
id,
name,
model,
... on Car {
fuelType
}
... on Bicycle {
gearCount,
isElectric
}
}
}
}
Neste exemplo, os campos comuns como id, name e model estão disponíveis em todos os tipos de objetos que implementam a interface Vehicle. No entanto, os campos específicos do tipo como fuelType para Car e gearCount e isElectric para Bicycle podem ser consultados usando fragmentos.
Se o cliente só precisa dos campos comuns, eles podem omitir os fragmentos:
query findCars() {
findCars() {
car {
id,
name,
model
}
}
}
Vantagens do Uso de Interfaces
- Reutilização de Código: Os campos comuns podem ser definidos na interface e compartilhados entre vários tipos, reduzindo a redundância.
- Logica Simplificada do Lado do Cliente: Os clientes não precisam fazer verificações condicionais para tipos de objetos. Eles podem solicitar tipos exatos e lidar com respostas com confiança.
- Extensibilidade de Esquema: Adicionar um novo campo comum se torna mais fácil, pois só precisa ser definido na interface.
- Estrutura Enforcada: As interfaces impõem uma estrutura compartilhada em todos os tipos que as implementam, garantindo consistência (por exemplo, todos os veículos devem ter um
id,nameemodel). - Consulta Unificada: Em vez de consultar diferentes tipos individualmente, os clientes podem consultar uma única interface para recuperar dados de todos os tipos que a implementam.
- Documentação Melhorada: Ao definir comportamentos comuns por meio de interfaces, torna-se mais fácil para os consumidores da API entender e trabalhar com tipos relacionados.
União GraphQL
Uma União no GraphQL é um tipo abstrato que permite aos clientes consultar vários tipos de objetos que estão relacionados de alguma forma através de um único campo. Ao contrário das interfaces, as uniões não exigem que os tipos membros compartilhem campos comuns. Isso torna as uniões ideais para lidar com casos em que os tipos relacionados têm estruturas diferentes, mas precisam ser consultados juntos.
type Query {
getPurchaseItems(): [PurchaseItem!]!
}
union PurchaseItem = Product | Service | Subscription
type Product {
id: ID!
productName: String!
price: Float!
}
type Service {
id: ID!
serviceName: String
duration: Float
}
type Subscription {
id: ID!
planName: String
billingCycle: String
}
Consulta do cliente GraphQL:
query getPurchaseItems() {
getPurchaseItems() {
purchaseItems {
... on Product {
id
productName
price
}
... on Service {
id
serviceName
duration
}
... on Subscription {
id
planName
billingCycle
}
}
}
}
Neste exemplo, Produto, Serviço e Assinatura são todos tipos distintos que pertencem à união ItemCompra. O cliente pode consultar os três tipos usando fragmentos em uma única consulta, mesmo que eles não compartilhem nenhum campo.
Nota importante sobre uniões, os tipos membros de um tipo União devem todos ser tipos de objeto base; Tipos Escalares, Interfaces e Uniões não podem ser tipos membros de uma União. Da mesma forma, os tipos de envolvimento não devem ser tipos membros de uma União.
Vantagens de Usar Uniões
- Agrupamento Flexível: Uniões permitem consultar tipos relacionados que não compartilham nenhum campo comum, o que seria complicado de lidar de outra forma.
- Manuseio Simplificado de Erros: Os clientes podem usar fragmentos para consultar tipos específicos, reduzindo a necessidade de lógica condicional complexa no lado do cliente.
- Manuseio de Dados Heterogêneos: Uma única consulta pode recuperar dados de vários tipos, simplificando o manuseio de estruturas de dados variadas.
- Útil para Respostas de Erro: As uniões são particularmente úteis quando você deseja combinar respostas de sucesso e detalhes de erro em um único tipo de resposta, permitindo que os clientes os lidem de forma eficiente.
Em Resumo
As Interfaces e Uniões do GraphQL oferecem maneiras poderosas de estruturar seu esquema GraphQL, possibilitando flexibilidade e simplificando as interações entre cliente e servidor. As Interfaces permitem campos compartilhados entre tipos, promovendo a reutilização de código e facilitando as extensões do esquema. Já as Uniões oferecem uma maneira de consultar tipos diversos juntos sem exigir campos comuns.
Source:
https://dzone.com/articles/a-beginners-guide-to-graphql-interfaces-and-unions