API GraphQL avec Go : tutoriel pratique étape par étape

Introduction

GraphQL est un langage de requête moderne pour les API, développé par Facebook. Contrairement à REST, il permet au client de demander uniquement les données nécessaires, ce qui réduit la charge réseau et accélère le développement. Dans ce tutoriel, nous allons créer une API GraphQL complète en langage Go (Golang) en utilisant la bibliothèque populaire gqlgen. Vous apprendrez à configurer le serveur, définir le schéma, écrire des résolveurs et exécuter des requêtes. Cet article s'adresse aux développeurs connaissant les bases de Go, mais même les débutants pourront suivre les étapes grâce à des commentaires détaillés.

1. Configuration du projet et installation des dépendances

Nous allons d'abord créer un nouveau projet Go et installer les paquets nécessaires.

Étape 1 : Initialisation du module

mkdir graphql-go-tutorialcd graphql-go-tutorialgo mod init graphql-go-tutorial

Étape 2 : Installation de gqlgen

gqlgen est un générateur de code GraphQL pour Go. Il crée automatiquement les résolveurs à partir du schéma.

go get github.com/99designs/gqlgen@latest

Étape 3 : Génération de la structure du projet

Exécutez la commande d'initialisation :

go run github.com/99designs/gqlgen init

Après exécution, vous verrez la structure suivante :

• graph/ — dossier contenant le schéma et les résolveurs
• server.go — point d'entrée
• gqlgen.yml — configuration du générateur

2. Définition du schéma GraphQL

Le schéma décrit les types de données et les opérations de l'API. Ouvrez le fichier graph/schema.graphqls et remplacez son contenu par ce qui suit :

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

type Query {  users: [User!]!  user(id: ID!): User}

type Mutation {  createUser(name: String!, email: String!, age: Int!): User!  updateUser(id: ID!, name: String, email: String, age: Int): User  deleteUser(id: ID!): Boolean}

Nous avons défini :

• User — un objet avec les champs id, name, email, age.
• Query — les opérations de lecture (obtenir tous les utilisateurs ou un seul par ID).
• Mutation — les opérations d'écriture (créer, mettre à jour, supprimer).

Après avoir enregistré, lancez la génération du code :

go run github.com/99designs/gqlgen generate

Cela créera les fichiers models_gen.go (types Go) et generated.go (interfaces des résolveurs).

3. Implémentation des résolveurs et du stockage de données

Il faut maintenant écrire la logique pour traiter les requêtes. Pour simplifier, nous stockerons les données en mémoire (tranche de structures).

Étape 1 : Création du stockage

Créez le fichier graph/store.go :

package graph

import "sync"

type Store struct {  mu    sync.RWMutex  users []User  nextID int}

func NewStore() *Store {  return &Store{    users: []User{      {ID: "1", Name: "Alice", Email: "alice@example.com", Age: 30},      {ID: "2", Name: "Bob", Email: "bob@example.com", Age: 25},    },    nextID: 3,  }}

func (s *Store) GetUsers() []User {  s.mu.RLock()  defer s.mu.RUnlock()  return s.users}

func (s *Store) GetUser(id string) *User {  s.mu.RLock()  defer s.mu.RUnlock()  for _, u := range s.users {    if u.ID == id {      return &u    }  }  return nil}

func (s *Store) CreateUser(name, email string, age int) User {  s.mu.Lock()  defer s.mu.Unlock()  user := User{    ID:    fmt.Sprintf("%d", s.nextID),    Name:  name,    Email: email,    Age:   age,  }  s.nextID++  s.users = append(s.users, user)  return user}

func (s *Store) UpdateUser(id string, name, email *string, age *int) *User {  s.mu.Lock()  defer s.mu.Unlock()  for i, u := range s.users {    if u.ID == id {      if name != nil {        s.users[i].Name = *name      }      if email