Schémas

Le schéma GraphQL est la base d'une API GraphQL. Il sert de modèle qui définit la forme de vos données. Il s'agit également d'un contrat entre votre client et votre serveur qui définit la manière dont vos données seront récupérées et/ou modifiées.

Les schémas GraphQL sont écrits dans le langage SDL (Schema Definition Language). SDL est composé de types et de champs dotés d'une structure établie :

• Types : Les types sont la façon dont GraphQL définit la forme et le comportement des données. GraphQL prend en charge une multitude de types qui seront expliqués plus loin dans cette section. Chaque type défini dans votre schéma contiendra sa propre portée. Le champ d'application comportera un ou plusieurs champs pouvant contenir une valeur ou une logique qui sera utilisée dans votre service GraphQL. Les types remplissent de nombreux rôles différents, les plus courants étant les objets ou les scalaires (types de valeurs primitives).

• Champs : les champs existent dans le cadre d'un type et contiennent la valeur demandée au service GraphQL. Elles sont très similaires aux variables d'autres langages de programmation. La forme des données que vous définissez dans vos champs déterminera la manière dont les données sont structurées lors d'une opération de demande/réponse. Cela permet aux développeurs de prévoir ce qui sera renvoyé sans savoir comment le backend du service est implémenté.

Pour visualiser à quoi ressemblerait un schéma, examinons le contenu d'un schéma GraphQL simple. Dans le code de production, votre schéma se trouve généralement dans un fichier appelé schema.graphql ouschema.json. Supposons que nous étudions un projet qui implémente un service GraphQL. Ce projet stocke les données du personnel de l'entreprise, et le schema.graphql fichier est utilisé pour récupérer les données sur le personnel et ajouter du nouveau personnel à une base de données. Le code peut ressembler à ceci :

schema.graphql

type Person {                                  
   id: ID!
   name: String                                  
   age: Int
}
type Query {                                   
  people: [Person]
}
type Mutation {
  addPerson(id: ID!, name: String, age: Int): Person
}

Nous pouvons voir qu'il existe trois types définis dans le schéma :Person,Query, etMutation. En regardantPerson, nous pouvons deviner qu'il s'agit du modèle d'une instance d'un employé de l'entreprise, ce qui ferait de ce type un objet. À l'intérieur de son champ d'applicationid, nous voyonsname, etage. Ce sont les champs qui définissent les propriétés d'unPerson. Cela signifie que notre source de données stocke chacun Person d'eux name en tant que type String scalaire (primitif) et age en tant que type Int scalaire (primitif). Il id agit comme un identifiant spécial et unique pour chacun d'entre euxPerson. Il s'agit également d'une valeur obligatoire, comme indiqué par le ! symbole.

Les deux types d'objets suivants se comportent différemment. GraphQL réserve quelques mots clés pour des types d'objets spéciaux qui définissent la manière dont les données seront renseignées dans le schéma. Un Query type récupérera les données de la source. Dans notre exemple, notre requête peut récupérer Person des objets d'une base de données. Cela peut vous rappeler les GET opérations utilisées dans la terminologie RESTful. A Mutation modifiera les données. Dans notre exemple, notre mutation peut ajouter d'autres Person objets à la base de données. Cela peut vous rappeler des opérations qui changent d'état, comme PUT ouPOST. Les comportements de tous les types d'objets spéciaux seront expliqués plus loin dans cette section.

Supposons que Query dans notre exemple, quelque chose soit extrait de la base de données. Si nous examinons les champs deQuery, nous voyons un champ appelépeople. La valeur de son champ est[Person]. Cela signifie que nous voulons récupérer une instance de Person dans la base de données. Cependant, l'ajout de crochets signifie que nous voulons renvoyer une liste de toutes les Person instances et pas seulement une instance spécifique.

Le Mutation type est chargé d'effectuer des opérations de changement d'état, telles que la modification des données. Une mutation est chargée d'effectuer une opération de changement d'état sur la source de données. Dans notre exemple, notre mutation contient une opération appelée addPerson qui ajoute un nouvel Person objet à la base de données. La mutation utilise un Person et attend une entrée pour les age champs idname, et.

À ce stade, vous vous demandez peut-être comment addPerson fonctionnent de telles opérations sans implémentation de code, étant donné qu'elles sont censées avoir un certain comportement et ressemblent beaucoup à une fonction avec un nom de fonction et des paramètres. Actuellement, cela ne fonctionne pas car un schéma ne sert que de déclaration. Pour implémenter le comportement deaddPerson, il faudrait y ajouter un résolveur. Un résolveur est une unité de code exécutée chaque fois que le champ associé (dans ce cas, l'addPersonopération) est appelé. Si vous souhaitez utiliser une opération, vous devrez ajouter l'implémentation du résolveur à un moment donné. D'une certaine manière, vous pouvez considérer l'opération du schéma comme la déclaration de fonction et le résolveur comme la définition. Les résolveurs seront expliqués dans une section différente.

Cet exemple montre uniquement les méthodes les plus simples utilisées par un schéma pour manipuler les données. Vous créez des applications complexes, robustes et évolutives en tirant parti des fonctionnalités de GraphQL et. AWS AppSync Dans la section suivante, nous définirons les différents types et comportements de champ que vous pouvez utiliser dans votre schéma.

Comme vous pouvez le constater, GraphQL comporte de nombreux composants mobiles. Dans cette section, nous avons présenté la structure d'un schéma simple ainsi que les différents types et champs qu'un schéma prend en charge. Dans la section suivante, vous découvrirez les autres composants d'une API GraphQL et leur fonctionnement avec le schéma.