¿Qué es GraphQL?
GraphQL es un lenguaje de consulta de código abierto para APIs, desarrollado inicialmente por Facebook en 2012 y lanzado al público en 2015. Ofrece una alternativa flexible y eficiente a las APIs REST tradicionales al permitir a los clientes solicitar solo los datos específicos que necesitan, resolviendo problemas de sobrecarga y subcarga que a menudo ocurren con las APIs REST.
Una de las razones de la creciente popularidad de GraphQL es su naturaleza impulsada por el cliente. Esto lo hace particularmente adecuado para aplicaciones modernas donde el rendimiento, la escalabilidad y las experiencias de usuario fluidas son críticas. GraphQL permite a los clientes combinar múltiples recursos en una sola solicitud, reduciendo el tráfico de red y convirtiéndolo en una excelente solución para aplicaciones móviles con ancho de banda limitado o necesidades complejas de front-end.
Grandes empresas como GitHub, Twitter, Indeed y Shopify han adoptado GraphQL, destacando su potencial para optimizar el desarrollo de APIs y mejorar las interacciones entre clientes y servidores.
Interfaz de GraphQL
En GraphQL, una Interfaz funciona de manera similar a las interfaces en la programación orientada a objetos. Es un tipo abstracto que define un conjunto de campos comunes que múltiples tipos de objeto pueden implementar. Esto asegura que el cliente pueda consultar con confianza estos campos comunes a través de 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
}
}
}
}
En este ejemplo, los campos comunes como id, name y model están disponibles en todos los tipos de objeto que implementan la interfaz Vehicle. Sin embargo, los campos específicos del tipo, como fuelType para Car y gearCount y isElectric para Bicycle, se pueden consultar utilizando fragmentos.
Si el cliente solo necesita campos comunes, puede omitir los fragmentos:
query findCars() {
findCars() {
car {
id,
name,
model
}
}
}
Beneficios de Usar Interfaces
- Reutilización de Código: Los campos comunes se pueden definir en la interfaz y compartirse entre múltiples tipos, reduciendo la redundancia.
- Logística Simplificada del Lado del Cliente: Los clientes no necesitan comprobaciones condicionales para los tipos de objeto. Pueden solicitar tipos exactos y manejar respuestas con confianza.
- Extensibilidad del Esquema: Agregar un nuevo campo común se vuelve más fácil ya que solo necesita definirse en la interfaz.
- Estructura Impuesta: Las interfaces imponen una estructura compartida entre todos los tipos que implementan, asegurando consistencia (por ejemplo, todos los vehículos deben tener un
id,nameymodel). - Consulta Unificada: En lugar de consultar diferentes tipos individualmente, los clientes pueden consultar una única interfaz para recuperar datos de todos los tipos que implementan.
- Documentación Mejorada: Al definir comportamientos comunes a través de interfaces, se vuelve más fácil para los consumidores de API entender y trabajar con tipos relacionados.
Unión GraphQL
Un Unión en GraphQL es un tipo abstracto que permite a los clientes consultar múltiples tipos de objeto que están relacionados en algún aspecto a través de un solo campo. A diferencia de las interfaces, las uniones no requieren que los tipos miembros compartan campos comunes. Esto hace que las uniones sean ideales para manejar casos donde los tipos relacionados tienen estructuras diferentes pero necesitan 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 del cliente de GraphQL:
query getPurchaseItems() {
getPurchaseItems() {
purchaseItems {
... on Product {
id
productName
price
}
... on Service {
id
serviceName
duration
}
... on Subscription {
id
planName
billingCycle
}
}
}
}
En este ejemplo, Producto, Servicio y Suscripción son todos tipos distintos que pertenecen a la unión PurchaseItem. El cliente puede consultar los tres tipos utilizando fragmentos en una sola consulta, a pesar de que no comparten ningún campo.
Nota importante sobre las uniones, los tipos miembros de un tipo Unión deben ser todos tipos base de Objeto; los tipos Escalar, Interfaz y Unión no deben ser tipos miembros de una Unión. De manera similar, los tipos de envoltura no deben ser tipos miembros de una Unión.
Beneficios de Usar Uniones
- Agrupación Flexible: Las uniones permiten consultar tipos relacionados que no comparten ningún campo común, lo que sería complicado de manejar de otra manera.
- Manejo de Errores Simplificado: Los clientes pueden usar fragmentos para consultar tipos específicos, reduciendo la necesidad de lógica condicional compleja en el lado del cliente.
- Manejo de Datos Heterogéneos: Una sola consulta puede recuperar datos de múltiples tipos, simplificando el manejo de estructuras de datos variadas.
- Útil para Respuestas de Error: Las uniones son particularmente útiles cuando deseas combinar respuestas de éxito y detalles de error en un solo tipo de respuesta, lo que permite a los clientes manejarlas de manera eficiente.
En Resumen
Las Interfaces y Uniones de GraphQL ofrecen formas poderosas de estructurar tu esquema GraphQL, permitiendo flexibilidad y simplificando las interacciones entre cliente y servidor. Las interfaces permiten campos compartidos entre tipos, promoviendo la reutilización de código y facilitando las extensiones del esquema. Las uniones, por otro lado, ofrecen una manera de consultar tipos dispares juntos sin requerir campos comunes.
Source:
https://dzone.com/articles/a-beginners-guide-to-graphql-interfaces-and-unions