Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Création de requêtes de base (VTL)
**Note**
Nous prenons désormais principalement en charge le runtime APPSYNC\_JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\_JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html)
Les résolveurs GraphQL connectent les champs d'un schéma de type à une source de données. Les résolveurs sont le mécanisme par lequel les demandes sont satisfaites. AWS AppSync peut créer et connecter automatiquement des résolveurs à partir d'un schéma ou créer un schéma et connecter des résolveurs à partir d'une table existante sans que vous ayez à écrire de code.
Résolveurs AWS AppSync utilisés JavaScript pour convertir une expression GraphQL dans un format utilisable par la source de données. Les modèles de mappage peuvent également être écrits dans le [langage VTL (Apache Velocity Template Language)](https://velocity.apache.org/engine/2.0/vtl-reference.html) pour convertir une expression GraphQL dans un format utilisable par la source de données.
Cette section explique comment configurer les résolveurs à l'aide de VTL. Un guide de programmation de type didacticiel d'introduction pour l'écriture de résolveurs se trouve dans le [guide de programmation du modèle de mappage Resolver](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide), et les utilitaires d'assistance disponibles pour la programmation se trouvent dans la référence contextuelle du modèle de mappage [Resolver](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference). AWS AppSync possède également des flux de test et de débogage intégrés que vous pouvez utiliser lorsque vous modifiez ou créez à partir de zéro. Pour plus d'informations, consultez la section [Tester et déboguer les résolveurs](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Nous vous recommandons de suivre ce guide avant d'essayer d'utiliser l'un des didacticiels mentionnés ci-dessus.
Dans cette section, nous expliquerons comment créer un résolveur, ajouter un résolveur pour les mutations et utiliser des configurations avancées.
## Créez votre premier résolveur
En suivant les exemples des sections précédentes, la première étape consiste à créer un résolveur adapté à votre `Query` type.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sur le côté droit de la page, il y a une fenêtre appelée **Resolvers**. Cette zone contient une liste des types et des champs tels que définis dans votre fenêtre de **schéma** sur le côté gauche de la page. Vous pouvez associer des résolveurs aux champs. Par exemple, sous le type de **requête**, choisissez **Joindre** à côté du `getTodos` champ.
1. Sur la page **Create Resolver**, choisissez la source de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). Dans la fenêtre **Configurer les modèles de mappage**, vous pouvez choisir à la fois les modèles de mappage de demande et de réponse génériques à l'aide de la liste déroulante de droite ou écrire le vôtre.
**Note**
L'appariement d'un modèle de mappage de demande à un modèle de mappage de réponse est appelé résolveur d'unités. Les résolveurs d'unités sont généralement conçus pour effectuer des opérations par cœur ; nous recommandons de les utiliser uniquement pour des opérations uniques avec un petit nombre de sources de données. Pour les opérations plus complexes, nous recommandons d'utiliser des résolveurs de pipeline, qui peuvent exécuter plusieurs opérations avec plusieurs sources de données de manière séquentielle.
Pour plus d'informations sur la différence entre les modèles de mappage de demandes et de réponses, consultez [Unit Resolvers](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Pour plus d'informations sur l'utilisation des résolveurs de pipeline, consultez la section [Résolveurs de pipeline](pipeline-resolvers.md#aws-appsync-pipeline-resolvers).
1. Pour les cas d'utilisation courants, la AWS AppSync console possède des modèles intégrés que vous pouvez utiliser pour obtenir des éléments à partir de sources de données (par exemple, toutes les requêtes relatives aux articles, les recherches individuelles, etc.). Par exemple, dans la version simple du schéma de [Designing your schema](designing-your-schema.md#aws-appsync-designing-your-schema) where `getTodos` didn't have pagination, le modèle de mappage des demandes pour la liste des éléments est le suivant :
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Vous avez toujours besoin d'un modèle de mappage des réponses pour accompagner la demande. La console fournit un modèle par défaut avec la valeur de transmission suivante pour les listes :
```
$util.toJson($ctx.result.items)
```
Dans cet exemple, l'objet `context` (dont l'alias est `$ctx`) pour les listes d'éléments se présente sous la forme `$context.result.items`. Si votre opération GraphQL renvoie un seul élément, ce serait `$context.result`. AWS AppSync fournit des fonctions d'assistant pour les opérations courantes, notamment la fonction `$util.toJson` répertoriée précédemment, pour mettre correctement en forme les réponses. Pour obtenir la liste complète des fonctions, consultez la [référence de l'utilitaire de modèle de mappage Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. Choisissez **Save Resolver.**
------
#### [ API ]
1. Créez un objet résolveur en appelant l'[https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html)API.
1. Vous pouvez modifier les champs de votre résolveur en appelant l'[https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html)API.
------
#### [ CLI ]
1. Créez un résolveur en exécutant la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)commande.
Vous devez saisir 6 paramètres pour cette commande particulière :
1. Celui `api-id` de votre API.
1. Le `type-name` type que vous souhaitez modifier dans votre schéma. Dans l'exemple de console, c'était le cas`Query`.
1. Le `field-name` champ que vous souhaitez modifier dans votre type. Dans l'exemple de console, c'était le cas`getTodos`.
1. La source `data-source-name` de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Le`request-mapping-template`, qui est le corps de la demande. Dans l'exemple de console, c'était :
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Le`response-mapping-template`, qui est le corps de la réponse. Dans l'exemple de console, c'était :
```
$util.toJson($ctx.result.items)
```
Voici un exemple de commande :
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Pour modifier les modèles de and/or mappage de champs d'un résolveur, exécutez la [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)commande.
À l'exception du `api-id` paramètre, les paramètres utilisés dans la `create-resolver` commande seront remplacés par les nouvelles valeurs de la `update-resolver` commande.
------
## Ajouter un résolveur pour les mutations
L'étape suivante consiste à créer un résolveur adapté à votre `Mutation` type.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sous le type de **mutation**, choisissez **Attacher** à côté du `addTodo` champ.
1. Sur la page **Create Resolver**, choisissez la source de données que vous avez créée dans le guide [Joindre une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Dans la fenêtre **Configurer les modèles de mappage**, vous devez modifier le modèle de demande car il s'agit d'une mutation dans laquelle vous ajoutez un nouvel élément à DynamoDB. Utilisez le modèle de mappage de demande suivant :
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync convertit automatiquement les arguments définis dans le `addTodo` champ à partir de votre schéma GraphQL en opérations DynamoDB. L'exemple précédent stocke les enregistrements dans DynamoDB à l'aide d'une clé `id` de, qui est transmise par l'argument de mutation sous la forme. `$ctx.args.id` Tous les autres champs que vous traversez sont automatiquement mappés aux attributs DynamoDB avec. `$util.dynamodb.toMapValuesJson($ctx.args)`
Pour ce résolveur, utilisez ensuite le modèle de mappage de réponse suivant :
```
$util.toJson($ctx.result)
```
AWS AppSync prend également en charge les flux de travail de test et de débogage pour l'édition de résolveurs. Vous pouvez utiliser un objet `context` simulé pour afficher la valeur transformée du modèle avant l'appel. Le cas échéant, vous pouvez afficher l'intégralité de l'exécution de la requête sur une source de données de façon interactive lorsque vous exécutez une requête. Pour plus d'informations, consultez les sections [Tester et déboguer les résolveurs](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) et [Surveillance et journalisation](monitoring.md#aws-appsync-monitoring).
1. Choisissez **Save Resolver.**
------
#### [ API ]
Vous pouvez également le faire APIs en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
#### [ CLI ]
Vous pouvez également le faire dans la CLI en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
À ce stade, si vous n'utilisez pas les résolveurs avancés, vous pouvez commencer à utiliser votre API GraphQL comme indiqué [dans Utilisation](using-your-api.md#aws-appsync-using-your-api) de votre API.
## Résolveurs avancés
Si vous suivez la section Avancé et que vous créez un exemple de schéma dans [Conception de votre schéma](designing-your-schema.md#aws-appsync-designing-your-schema) pour effectuer un scan paginé, utilisez plutôt le modèle de demande suivant pour le `getTodos` champ :
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
Pour ce scénario de pagination, le mappage de réponse est plus qu'une simple transmission, car il doit contenir à la fois le *curseur* (afin que le client sache quelle est la prochaine page à démarrer) et le jeu de résultats. Le modèle de mappage est ainsi :
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Les champs du précédent modèle de mappage de réponse doivent correspondre aux champs définis dans votre type `TodoConnection`.
Dans le cas de relations où vous avez une `Comments` table et que vous résolvez le champ de commentaires sur le `Todo` type (qui renvoie un type de`[Comment]`), vous pouvez utiliser un modèle de mappage qui exécute une requête sur la deuxième table. Pour ce faire, vous devez déjà avoir créé une source de données pour la `Comments` table, comme indiqué dans la section [Joindre une source de données](attaching-a-data-source.md#aws-appsync-getting-started-build-a-schema-from-scratch).
**Note**
Nous utilisons une opération de requête sur une deuxième table à des fins d'illustration uniquement. Vous pouvez utiliser une autre opération sur DynamoDB à la place. En outre, vous pouvez extraire les données d'une autre source de données, telle qu' AWS Lambda Amazon OpenSearch Service, car la relation est contrôlée par votre schéma GraphQL.
------
#### [ Console ]
1. Connectez-vous à la [AppSync console AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Sous le type **Todo**, choisissez **Joindre** à côté du `comments` champ.
1. Sur la page **Créer un résolveur**, choisissez la source de données de votre table de **commentaires**. Le nom par défaut du tableau des **commentaires** dans les guides de démarrage rapide est`AppSyncCommentTable`, mais il peut varier en fonction du nom que vous lui avez donné.
1. Ajoutez l'extrait suivant à votre modèle de mappage de demandes :
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. Le `context.source` fait référence à l'objet parent du champ actif en cours de résolution. Dans cet exemple, `source.id` fait référence à l'objet `Todo` individuel, qui est ensuite utilisé pour l'expression de la requête.
Vous pouvez utiliser le modèle de mappage de réponse de transmission, comme suit :
```
$util.toJson($ctx.result.items)
```
1. Choisissez **Save Resolver.**
1. Enfin, revenez sur la page **Schéma** de la console, attachez un résolveur au `addComment` champ et spécifiez la source de données de la `Comments` table. Dans ce cas, le modèle de mappage de requête est un simple `PutItem` avec le `todoid` spécifique qui est commenté en tant qu'argument, mais vous utilisez l'utilitaire `$utils.autoId()` pour créer une clé de tri unique pour le commentaire de la façon suivante :
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Utilisez un modèle de réponse de transmission comme suit :
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Vous pouvez également le faire APIs en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------
#### [ CLI ]
Vous pouvez également le faire dans la CLI en utilisant les commandes de la section [Créez votre premier résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) et les détails des paramètres de cette section.
------