Réponses à vos 10 questions GraphQL les plus courantes —

Dans cet article, nous répondrons aux dix questions les plus fréquemment posées sur GraphQL, couvrant la pagination, la gestion des versions de graphQL, le chargement par lots, la gestion du cache, les téléchargements de fichiers, etc.

1. Comment gérer les erreurs dans GraphQL ?

Dans GraphQL, les erreurs sont gérées en renvoyant un errors champ dans la réponse. Le errors champ est un tableau d’objets d’erreur, chacun contenant un message et éventuellement d’autres champs avec des informations supplémentaires.

Pour gérer les erreurs côté serveur, vous pouvez générer des erreurs personnalisées dans vos résolveurs. Par exemple, en JavaScript :

throw new Error('Something went wrong');

Côté client, vous pouvez vérifier la présence du errors dans la réponse et traitez-les en conséquence.

2. Comment paginer les résultats dans GraphQL ?

Pour paginer les résultats dans GraphQL, vous pouvez utiliser le modèle « Connexion », qui consiste à utiliser des « arêtes » et des « nœuds » pour représenter les connexions entre les objets. Vous pouvez également utiliser des arguments tels que first, last, beforeet after pour contrôler la pagination.

Voici un exemple de schéma pour paginer une liste d’utilisateurs :

type Query {
users(first: Int, after: String): UserConnection
}

type UserConnection {
edges: [UserEdge]
pageInfo: PageInfo
}

type UserEdge {
node: User
cursor: String
}

type PageInfo {
hasNextPage: Boolean
endCursor: String
}

Dans votre résolveur, vous implémenterez la logique pour récupérer les données paginées et renvoyer l’objet de connexion approprié.

3. Comment gérer l’authentification et l’autorisation dans GraphQL ?

L’authentification et l’autorisation ne sont pas intégrées à GraphQL, mais vous pouvez les implémenter à l’aide d’un middleware ou d’un contexte. Pour l’authentification, vous pouvez utiliser une approche basée sur des jetons (telle que JWT) ou tout autre mécanisme d’authentification.

Dans votre serveur GraphQL, vous pouvez ajouter un middleware pour vérifier le jeton d’authentification et ajouter l’utilisateur authentifié au contexte. Dans vos résolveurs, vous pouvez accéder au contexte pour vérifier si l’utilisateur est authentifié et autorisé à effectuer l’opération demandée.

Par exemple, en JavaScript :

const authenticationMiddleware = async (req, res, next) => {
const token = req.headers.authorization;
const user = await verifyToken(token);
req.user = user;
next();
};


const context = ({ req }) => {
return { user: req.user };
};


const resolver = {
Query: {
protectedData: (parent, args, context) => {
if (!context.user) {
throw new Error('Not authenticated');
}

},
},
};

4. Comment gérer les mises à jour en temps réel avec GraphQL ?

Pour gérer les mises à jour en temps réel dans GraphQL, vous pouvez utiliser des abonnements. Les abonnements permettent aux clients de recevoir des mises à jour lorsque des événements spécifiques se produisent sur le serveur.

Pour implémenter des abonnements, vous devez définir un Subscription tapez votre schéma et utilisez le subscribe dans vos résolveurs pour définir les événements qui déclenchent les mises à jour.

Par exemple:

type Subscription {
userCreated: User
}

Dans votre résolveur, vous pouvez utiliser un émetteur d’événements ou un système pub/sub pour gérer les abonnements :

const { PubSub } = require('graphql-subscriptions');
const pubsub = new PubSub();

const USER_CREATED = 'USER_CREATED';

const resolvers = {
Subscription: {
userCreated: {
subscribe: () => pubsub.asyncIterator(USER_CREATED),
},
},
Mutation: {
createUser: (parent, args) => {
const newUser = createUser(args);
pubsub.publish(USER_CREATED, { userCreated: newUser });
return newUser;
},
},
};

5. Comment gérer les téléchargements de fichiers avec GraphQL ?

GraphQL n’a pas de support intégré pour les téléchargements de fichiers, mais vous pouvez utiliser le graphql-upload package pour gérer les téléchargements de fichiers dans votre serveur GraphQL.

Tout d’abord, installez le package :

npm install graphql-upload

Ensuite, ajoutez le Upload scalaire à votre schéma :

scalar Upload

type Mutation {
uploadFile(file: Upload!): File
}

Dans votre résolveur, vous pouvez utiliser le createReadStream méthode pour gérer le fichier téléchargé :

const { GraphQLUpload } = require('graphql-upload');

const resolvers = {
Upload: GraphQLUpload,
Mutation: {
uploadFile: async (parent, { file }) => {
const { createReadStream, filename, mimetype } = await file;

return { filename, mimetype };
},
},
};

6. Comment gérer la mise en cache dans GraphQL ?

La mise en cache dans GraphQL peut être implémentée à la fois côté client et côté serveur. Côté client, vous pouvez utiliser des bibliothèques comme Apollo Client ou Relay, qui fournissent des mécanismes de mise en cache intégrés.

Côté serveur, vous pouvez implémenter la mise en cache à l’aide de DataLoader, un utilitaire fourni par Facebook qui permet de regrouper et de mettre en cache les opérations de récupération de données. DataLoader peut être utilisé pour mettre en cache des requêtes de base de données, des appels d’API ou toute autre opération de récupération de données.

Tout d’abord, installez DataLoader :

npm install dataloader

Ensuite, créez un DataLoader instance pour chaque opération de récupération de données que vous souhaitez mettre en cache :

const DataLoader = require('dataloader');

const userLoader = new DataLoader(async (userIds) => {
const users = await getUsersByIds(userIds);
return userIds.map((id) => users.find((user) => user.id === id));
});

Dans vos résolveurs, utilisez le DataLoader instance pour récupérer les données :

const resolvers = {
Query: {
user: (parent, { id }) => userLoader.load(id),
},
};

7. Comment gérer le chargement par lots dans GraphQL ?

Le chargement par lots peut être implémenté à l’aide de DataLoader, qui facilite le traitement par lots et la mise en cache des opérations de récupération de données. DataLoader regroupe plusieurs requêtes pour le même type de données en un seul lot, réduisant ainsi le nombre de requêtes de base de données ou d’appels d’API.

Suivez les mêmes étapes que dans l’exemple de mise en cache ci-dessus pour créer un DataLoader instance et utilisez-la dans vos résolveurs.

8. Comment gérer les problèmes de requête N+1 dans GraphQL ?

Le problème de requête N+1 se produit lorsque plusieurs requêtes sont exécutées pour extraire des données associées, ce qui entraîne une extraction de données inefficace. DataLoader peut aider à résoudre le problème de requête N+1 en regroupant et en mettant en cache les opérations de récupération de données.

En utilisant DataLoader dans vos résolveurs, vous pouvez vous assurer que les données associées sont récupérées en un seul lot, ce qui réduit le nombre de requêtes et améliore les performances.

9. Comment gérer l’assemblage de schémas ou la fédération de schémas dans GraphQL ?

L’assemblage de schémas et la fédération de schémas sont des techniques utilisées pour combiner plusieurs schémas GraphQL en un seul schéma.

L’assemblage de schémas peut être mis en œuvre à l’aide de la graphql-tools emballer. Tout d’abord, installez le package :

npm install graphql-tools

Ensuite, utilisez le mergeSchemas fonction pour combiner vos schémas :

const { mergeSchemas } = require('graphql-tools');

const schema1 = makeExecutableSchema({ typeDefs: typeDefs1, resolvers: resolvers1 });
const schema2 = makeExecutableSchema({ typeDefs: typeDefs2, resolvers: resolvers2 });

const mergedSchema = mergeSchemas({ schemas: [schema1, schema2] });

La fédération de schéma peut être implémentée à l’aide d’Apollo Federation. Tout d’abord, installez les packages requis :

npm install @apollo/federation @apollo/gateway

Ensuite, utilisez le buildFederatedSchema pour créer un schéma fédéré pour chaque service :

const { buildFederatedSchema } = require('@apollo/federation');

const schema1 = buildFederatedSchema([{ typeDefs: typeDefs1, resolvers: resolvers1 }]);
const schema2 = buildFederatedSchema([{ typeDefs: typeDefs2, resolvers: resolvers2 }]);

Enfin, utilisez le ApolloGateway class pour créer une passerelle qui combine les schémas fédérés :

const { ApolloGateway } = require('@apollo/gateway');

const gateway = new ApolloGateway({
serviceList: [
{ name: 'service1', url: 'http://localhost:4001' },
{ name: 'service2', url: 'http://localhost:4002' },
],
});

10. Comment gérer le versioning dans GraphQL ?

GraphQL n’a pas de support intégré pour la gestion des versions, mais vous pouvez gérer la gestion des versions en faisant évoluer votre schéma au fil du temps. Au lieu de créer plusieurs versions de votre API, vous pouvez ajouter de nouveaux champs, types ou arguments à votre schéma tout en maintenant la compatibilité descendante.

Pour déprécier des champs ou des arguments, vous pouvez utiliser le deprecationReason directif:

type User {
id: ID!
name: String!
email: String @deprecated(reason: "Use 'username' instead")
}

En faisant évoluer votre schéma et en utilisant l’obsolescence, vous pouvez gérer la gestion des versions sans casser les clients existants.