Les concepts fondamentaux de GraphQL

GraphQL est une technologie riche, bâtie autour de concepts bien définis qui facilitent la création et la gestion des APIs. Ces concepts fondamentaux incluent le schéma, les types, les requêtes, les mutations et les subscriptions.

Le Schéma (Schema)

Le schéma est la pierre angulaire d’une API GraphQL. Il définit :

• Les types de données disponibles : Ce que le client peut demander.
• Les relations entre ces types : Comment les différentes entités sont connectées.
• Les opérations possibles : Quelles actions peuvent être effectuées, comme récupérer ou modifier des données.

Structure d’un schéma :

Le schéma utilise un langage spécifique, appelé SDL (Schema Definition Language). Par exemple :

type User {
  id: ID!
  name: String!
  email: String!
  age: Int
}

Principaux éléments d’un schéma :

• Query : Définit les opérations pour lire les données.
• Mutation : Définit les opérations pour modifier ou écrire des données.
• Subscription : Définit les opérations pour écouter les mises à jour en temps réel.

Les Types

GraphQL repose sur un système de typage strict qui assure la cohérence et la validation des données échangées.

Types scalaires de base :

Les types scalaires sont les blocs de base pour représenter des données simples :

• String : Texte.
• Int : Entiers.
• Float : Nombres décimaux.
• Boolean : true ou false.
• ID : Identifiant unique, souvent utilisé pour les clés primaires.

Types personnalisés (Objets) :

Les types personnalisés permettent de structurer des données plus complexes. Par exemple, un type utilisateur :

type User {
  id: ID!
  name: String!
  email: String
  friends: [User]
}

Enums et Listes :

• Enums : Définissent un ensemble de valeurs possibles pour une propriété :

  enum Role {
    ADMIN
    USER
    GUEST
  }
• Listes : Utilisées pour représenter des collections de données. Par exemple, [User] est une liste d’utilisateurs.

Les Requêtes (Query)

Les requêtes permettent de récupérer les données depuis le serveur. Ce qui distingue GraphQL, c’est la possibilité pour le client de spécifier exactement les champs nécessaires.

Exemple de requête simple :

query {
  user(id: 1) {
    name
    email
  }
}

Caractéristiques principales :

• Précision : Le client obtient uniquement les champs demandés.
• Relations : Les requêtes peuvent suivre des relations complexes entre types.

Les Mutations

Les mutations permettent de modifier ou d’ajouter des données sur le serveur.

Exemple de mutation :

Créer un nouvel utilisateur :

mutation {
  createUser(input: { name: "Alice", email: "alice@example.com" }) {
    id
    name
  }
}

Retour structuré :

Les mutations retournent les données modifiées ou créées, dans le même format que les requêtes.

Les Subscriptions

Les subscriptions permettent d’écouter les changements de données en temps réel, souvent à l’aide de WebSockets.

Cas d’utilisation :

• Suivi des notifications en direct.
• Affichage de mises à jour dans une application de chat.

Exemple de subscription :

subscription {
  messageAdded {
    content
    sender
  }
}

Résumé des concepts fondamentaux

Dans les prochaines sections, nous détaillerons chacun de ces concepts avec des exemples pratiques et leur implémentation.