Qu’est-ce que GraphQL?
GraphQL est un langage de requête open-source pour les API, initialement développé par Facebook en 2012 et rendu public en 2015. Il offre une alternative flexible et efficace aux API REST traditionnelles en permettant aux clients de demander uniquement les données spécifiques dont ils ont besoin, résolvant ainsi les problèmes de sur-récupération et de sous-récupération qui surviennent souvent avec les API REST.
Une des raisons de la popularité croissante de GraphQL est sa nature axée sur le client. Cela le rend particulièrement adapté aux applications modernes où les performances, la scalabilité et les expériences utilisateur fluides sont essentielles. GraphQL permet aux clients de combiner plusieurs ressources dans une seule requête, réduisant le trafic réseau et en faisant une excellente solution pour les applications mobiles avec une bande passante limitée ou des besoins frontend complexes.
Des grandes entreprises comme GitHub, Twitter, Indeed et Shopify ont adopté GraphQL, mettant en avant son potentiel pour rationaliser le développement d’API et améliorer les interactions client-serveur.
Interface GraphQL
En GraphQL, une Interface fonctionne de manière similaire aux interfaces en programmation orientée objet. C’est un type abstrait qui définit un ensemble de champs communs que plusieurs types d’objets peuvent implémenter. Cela garantit que le client peut interroger en toute confiance ces champs communs à travers différents types.
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!
}
Requête client GraphQL:
query findVehicles() {
findVehicles() {
vehicle {
id,
name,
model,
... on Car {
fuelType
}
... on Bicycle {
gearCount,
isElectric
}
}
}
}
Dans cet exemple, les champs communs tels que id, name et model sont disponibles pour tous les types d’objets qui implémentent l’interface Vehicle. Cependant, les champs spécifiques aux types tels que fuelType pour Car et gearCount et isElectric pour Bicycle peuvent être interrogés à l’aide de fragments.
Si le client n’a besoin que des champs communs, il peut omettre les fragments :
query findCars() {
findCars() {
car {
id,
name,
model
}
}
}
Avantages de l’utilisation des interfaces
- Réutilisabilité du code : Les champs communs peuvent être définis dans l’interface et partagés entre plusieurs types, réduisant la redondance.
- Logique simplifiée côté client : Les clients n’ont pas besoin de vérifications conditionnelles pour les types d’objets. Ils peuvent demander des types exacts et gérer les réponses en toute confiance.
- Extensibilité du schéma : Ajouter un nouveau champ commun devient plus facile car il doit simplement être défini dans l’interface.
- Structure imposée : Les interfaces imposent une structure partagée à tous les types implémentant, assurant une cohérence (par exemple, tous les véhicules doivent avoir un
id, unnameet unmodel). - Interrogation unifiée : Au lieu d’interroger différents types individuellement, les clients peuvent interroger une seule interface pour récupérer des données de tous les types implémentant.
- Documentation améliorée : En définissant des comportements communs à travers les interfaces, il devient plus facile pour les consommateurs de l’API de comprendre et de travailler avec des types connexes.
Union GraphQL
Un Union en GraphQL est un type abstrait qui permet aux clients de interroger plusieurs types d’objets qui sont liés d’une certaine manière à travers un seul champ. Contrairement aux interfaces, les unions ne nécessitent pas que les types membres partagent des champs communs. Cela rend les unions idéales pour traiter les cas où les types apparentés ont des structures différentes mais doivent être interrogés ensemble.
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
}
Requête client GraphQL :
query getPurchaseItems() {
getPurchaseItems() {
purchaseItems {
... on Product {
id
productName
price
}
... on Service {
id
serviceName
duration
}
... on Subscription {
id
planName
billingCycle
}
}
}
}
Dans cet exemple, Product, Service et Subscription sont tous des types distincts appartenant à l’union PurchaseItem. Le client peut interroger les trois types en utilisant des fragments dans une seule requête, même s’ils ne partagent aucun champ.
Note importante concernant les unions, les types membres d’un type Union doivent tous être des types de base d’objet ; les types Scalar, Interface et Union ne doivent pas être des types membres d’une Union. De même, les types d’enveloppe ne doivent pas être des types membres d’une Union.
Avantages de l’utilisation des Unions
- Regroupement flexible : Les unions permettent d’interroger des types apparentés qui ne partagent aucun champ commun, ce qui serait fastidieux à gérer autrement.
- Gestion des erreurs simplifiée : Les clients peuvent utiliser des fragments pour interroger des types spécifiques, réduisant ainsi le besoin de logique conditionnelle complexe côté client.
- Gestion de données hétérogènes : Une seule requête peut récupérer des données de plusieurs types, simplifiant la gestion de structures de données variées.
- Utile pour les réponses d’erreur : Les unions sont particulièrement utiles lorsque vous souhaitez combiner les réponses de succès et les détails d’erreur dans un seul type de réponse, permettant aux clients de les gérer efficacement.
En résumé
Les interfaces et les unions de GraphQL offrent des moyens puissants pour structurer votre schéma GraphQL, permettant la flexibilité et simplifiant les interactions client-serveur. Les interfaces permettent des champs partagés entre les types, favorisant la réutilisation du code et les extensions de schéma plus faciles. Les unions, en revanche, offrent un moyen de interroger des types disparates ensemble sans nécessiter de champs communs.
Source:
https://dzone.com/articles/a-beginners-guide-to-graphql-interfaces-and-unions