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 d'une post-application simple à l'aide des résolveurs DynamoDB JavaScript Dans ce didacticiel, vous allez importer vos tables Amazon DynamoDB et les connecter AWS AppSync pour créer une API GraphQL entièrement fonctionnelle à l' JavaScript aide de résolveurs de pipeline que vous pouvez exploiter dans votre propre application. Vous utiliserez la AWS AppSync console pour approvisionner vos ressources Amazon DynamoDB, créer vos résolveurs et les connecter à vos sources de données. Vous pourrez également lire et écrire dans votre base de données Amazon DynamoDB via des instructions GraphQL et vous abonner à des données en temps réel. Certaines étapes spécifiques doivent être effectuées pour que les instructions GraphQL soient traduites en opérations Amazon DynamoDB et pour que les réponses soient retraduites dans GraphQL. Ce didacticiel explique le processus de configuration par le biais de plusieurs scénarios et modèles d'accès aux données concrets. ## Création de votre API GraphQL **Pour créer une API GraphQL dans AWS AppSync** 1. Ouvrez la AppSync console et choisissez **Create API**. 1. Sélectionnez **Design from scratch** et choisissez **Next**. 1. Donnez un nom à votre API`PostTutorialAPI`, puis choisissez **Next**. Passez à la page de révision tout en conservant les valeurs par défaut pour les autres options, puis choisissez`Create`. La AWS AppSync console crée une nouvelle API GraphQL pour vous. Par défaut, il utilise le mode d'authentification par clé API. Vous pouvez utiliser la console pour configurer le reste de l'API GraphQL et exécuter des requêtes sur celle-ci jusqu'à la fin de ce didacticiel. ## Définition d'une API de publication de base Maintenant que vous disposez de votre API GraphQL, vous pouvez configurer un schéma de base qui permet la création, la récupération et la suppression de base des données de publication. **Pour ajouter des données à votre schéma** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Nous allons créer un schéma qui définit un `Post` type et une opération `addPost` pour ajouter et obtenir `Post` des objets. Dans le volet **Schéma**, remplacez le contenu par le code suivant : ``` schema { query: Query mutation: Mutation } type Query { getPost(id: ID): Post } type Mutation { addPost( id: ID! author: String! title: String! content: String! url: String! ): Post! } type Post { id: ID! author: String title: String content: String url: String ups: Int! downs: Int! version: Int! } ``` 1. Choisissez **Sauvegarder schéma**. ## Configuration de votre table Amazon DynamoDB La AWS AppSync console peut vous aider à fournir les AWS ressources nécessaires pour stocker vos propres ressources dans une table Amazon DynamoDB. Au cours de cette étape, vous allez créer une table Amazon DynamoDB pour stocker vos publications. Vous allez également configurer un [index secondaire](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) que nous utiliserons ultérieurement. **Pour créer votre table Amazon DynamoDB** 1. Sur la page **Schéma**, choisissez **Create Resources**. 1. Choisissez **Utiliser le type existant**, puis choisissez le `Post` type. 1. Dans la section **Index supplémentaires**, choisissez **Ajouter un index**. 1. Donnez un nom à l'index`author-index`. 1. Réglez le `Primary key` point sur `author` et la `Sort` touche sur`None`. 1. Désactivez **Générer automatiquement GraphQL**. Dans cet exemple, nous allons créer le résolveur nous-mêmes. 1. Choisissez **Créer**. Vous avez maintenant une nouvelle source de données appelée`PostTable`, que vous pouvez consulter en accédant à **Sources de données** dans l'onglet latéral. Vous utiliserez cette source de données pour lier vos requêtes et mutations à votre table Amazon DynamoDB. ## Configuration d'un résolveur AddPost (Amazon DynamoDB) PutItem Maintenant AWS AppSync que vous connaissez la table Amazon DynamoDB, vous pouvez la lier à des requêtes et à des mutations individuelles en définissant des résolveurs. Le premier résolveur que vous créez est le résolveur de `addPost` pipeline utilisé JavaScript, qui vous permet de créer une publication dans votre table Amazon DynamoDB. Un résolveur de pipeline comporte les composants suivants : + L'emplacement dans le schéma GraphQL pour joindre le résolveur. Dans ce cas, vous configurez un résolveur sur le champ `createPost` sur le type `Mutation`. Ce résolveur sera invoqué lorsque l'appelant appellera une mutation. `{ addPost(...){...} }` + La source de données à utiliser pour ce résolveur. Dans ce cas, vous souhaitez utiliser la source de données DynamoDB que vous avez définie précédemment afin de pouvoir ajouter des entrées dans la `post-table-for-tutorial` table DynamoDB. + Le gestionnaire de demandes. Le gestionnaire de demandes est une fonction qui gère la demande entrante de l'appelant et la traduit en instructions AWS AppSync à exécuter par rapport à DynamoDB. + Le gestionnaire de réponses. Le rôle du gestionnaire de réponse est de gérer la réponse de DynamoDB et de la retraduire en une réponse attendue par GraphQL. Cela est utile si la forme des données dans DynamoDB est différente du type `Post` dans GraphQL, mais dans ce cas, ils ont la même forme, de sorte que vous transmettez simplement les données. **Pour configurer votre résolveur** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Résolveurs**, recherchez le `addPost` champ situé sous le `Mutation` type, puis choisissez **Attacher**. 1. Choisissez votre source de données, puis sélectionnez **Créer**. 1. Dans votre éditeur de code, remplacez le code par cet extrait : ``` import { util } from '@aws-appsync/utils' import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 } const key = { id: ctx.args.id ?? util.autoId() } return ddb.put({ key, item }) } export function response(ctx) { return ctx.result } ``` 1. Choisissez **Enregistrer**. **Note** Dans ce code, vous utilisez les utilitaires du module DynamoDB qui vous permettent de créer facilement des requêtes DynamoDB. AWS AppSync est livré avec un utilitaire de génération automatique d'identifiant appelé`util.autoId()`, qui est utilisé pour générer un identifiant pour votre nouveau message. Si vous ne spécifiez pas d'identifiant, l'utilitaire le générera automatiquement pour vous. ``` const key = { id: ctx.args.id ?? util.autoId() } ``` Pour plus d'informations sur les utilitaires disponibles pour JavaScript, consultez les [fonctionnalités JavaScript d'exécution pour les résolveurs et les fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html). ### Appelez l'API pour ajouter une publication Maintenant que le résolveur a été configuré, il AWS AppSync peut traduire une `addPost` mutation entrante en une opération Amazon DynamoDB`PutItem`. Vous pouvez désormais exécuter une mutation pour placer quelque chose dans la table. **Pour exécuter l'opération** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante : ``` mutation addPost { addPost( id: 123, author: "AUTHORNAME" title: "Our first post!" content: "This is our first post." url: "https://aws.amazon.com/appsync/" ) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`addPost`. Les résultats de la publication nouvellement créée doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "addPost": { "id": "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` L'explication suivante montre ce qui s'est passé : 1. AWS AppSync a reçu une demande de `addPost` mutation. 1. AWS AppSync exécute le gestionnaire de requêtes du résolveur. La `ddb.put` fonction crée une `PutItem` demande qui ressemble à ceci : ``` { operation: 'PutItem', key: { id: { S: '123' } }, attributeValues: { downs: { N: 0 }, author: { S: 'AUTHORNAME' }, ups: { N: 1 }, title: { S: 'Our first post!' }, version: { N: 1 }, content: { S: 'This is our first post.' }, url: { S: 'https://aws.amazon.com/appsync/' } } } ``` 1. AWS AppSync utilise cette valeur pour générer et exécuter une demande Amazon `PutItem` DynamoDB. 1. AWS AppSync a pris les résultats de la `PutItem` requête et les a reconvertis en types GraphQL. ``` { "id" : "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups" : 1, "downs" : 0, "version" : 1 } ``` 1. Le gestionnaire de réponses renvoie le résultat immédiatement (`return ctx.result`). 1. Le résultat final est visible dans la réponse GraphQL. ## Configuration du résolveur GetPost (Amazon DynamoDB) GetItem Maintenant que vous pouvez ajouter des données à la table Amazon DynamoDB, vous devez configurer `getPost` la requête afin qu'elle puisse extraire ces données de la table. Pour ce faire, vous configurez un autre résolveur. **Pour ajouter votre résolveur** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Resolvers** sur la droite, recherchez le `getPost` champ correspondant au `Query` type, puis choisissez **Attacher**. 1. Choisissez votre source de données, puis sélectionnez **Créer**. 1. Dans l'éditeur de code, remplacez le code par cet extrait : ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.get({ key: { id: ctx.args.id } }) } export const response = (ctx) => ctx.result ``` 1. Enregistrez votre résolveur. **Note** Dans ce résolveur, nous utilisons une expression de fonction flèche pour le gestionnaire de réponses. ### Appelez l'API pour obtenir un message Maintenant que le résolveur est configuré, AWS AppSync il sait comment traduire une `getPost` requête entrante en une opération Amazon DynamoDB`GetItem`. Vous pouvez désormais exécuter une requête pour récupérer la publication que vous avez créée précédemment. **Pour exécuter votre requête** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez le code suivant et utilisez l'identifiant que vous avez copié après avoir créé votre publication : ``` query getPost { getPost(id: "123") { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`getPost`. Les résultats de la publication nouvellement créée doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. 1. **La publication extraite d'Amazon DynamoDB doit apparaître dans **le** volet Résultats à droite du volet Requêtes.** Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "getPost": { "id": "123", "author": "AUTHORNAME", "title": "Our first post!", "content": "This is our first post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` Vous pouvez également prendre l'exemple suivant : ``` query getPost { getPost(id: "123") { id author title } } ``` Si votre `getPost` requête n'a besoin que du`id`, et `author``title`, vous pouvez modifier votre fonction de demande pour utiliser des expressions de projection afin de spécifier uniquement les attributs que vous souhaitez voir apparaître dans votre table DynamoDB afin d'éviter tout transfert de données inutile de DynamoDB vers. AWS AppSync Par exemple, la fonction de requête peut ressembler à l'extrait ci-dessous : ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.get({ key: { id: ctx.args.id }, projection: ['author', 'id', 'title'], }) } export const response = (ctx) => ctx.result ``` Vous pouvez également utiliser un [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js)signe avec `getPost` pour représenter `expression` : ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.')) return ddb.get({ key: { id: ctx.args.id }, projection }) } export const response = (ctx) => ctx.result ``` ## Création d'une mutation UpdatePost (Amazon DynamoDB) UpdateItem Jusqu'à présent, vous pouvez créer et récupérer `Post` des objets dans Amazon DynamoDB. Vous allez ensuite configurer une nouvelle mutation pour mettre à jour un objet. Comparée à la `addPost` mutation qui nécessite que tous les champs soient spécifiés, cette mutation vous permet de spécifier uniquement les champs que vous souhaitez modifier. Il a également introduit un nouvel `expectedVersion` argument qui vous permet de spécifier la version que vous souhaitez modifier. Vous allez définir une condition garantissant que vous modifiez la dernière version de l'objet. Pour ce faire, utilisez l'opération `UpdateItem` Amazon DynamoDB .sc **Pour mettre à jour votre résolveur** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le type `Mutation` pour ajouter une nouvelle mutation `updatePost` : ``` type Mutation { updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( id: ID author: String! title: String! content: String! url: String! ): Post! } ``` 1. Choisissez **Sauvegarder schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `updatePost` champ nouvellement créé sur le `Mutation` type, puis choisissez **Joindre**. Créez votre nouveau résolveur à l'aide de l'extrait ci-dessous : ``` import { util } from '@aws-appsync/utils'; import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { id, expectedVersion, ...rest } = ctx.args; const values = Object.entries(rest).reduce((obj, [key, value]) => { obj[key] = value ?? ddb.operations.remove(); return obj; }, {}); return ddb.update({ key: { id }, condition: { version: { eq: expectedVersion } }, update: { ...values, version: ddb.operations.increment(1) }, }); } export function response(ctx) { const { error, result } = ctx; if (error) { util.appendError(error.message, error.type); } return result; ``` 1. Enregistrez toutes les modifications que vous avez apportées. Ce résolveur permet `ddb.update` de créer une demande Amazon DynamoDB`UpdateItem`. Au lieu de rédiger l'article dans son intégralité, vous demandez simplement à Amazon DynamoDB de mettre à jour certains attributs. Cela se fait à l'aide des expressions de mise à jour Amazon DynamoDB. La `ddb.update` fonction prend une clé et un objet de mise à jour comme arguments. Ensuite, vous vérifiez les valeurs des arguments entrants. Lorsqu'une valeur est définie sur`null`, utilisez l'opération `remove` DynamoDB pour signaler que la valeur doit être supprimée de l'élément DynamoDB. Il y a également une nouvelle `condition` section. Une expression de condition vous permet de dire AWS AppSync à Amazon DynamoDB si la demande doit aboutir ou non en fonction de l'état de l'objet déjà présent dans Amazon DynamoDB avant que l'opération ne soit effectuée. Dans ce cas, vous souhaitez que la `UpdateItem` demande aboutisse uniquement si le `version` champ de l'article actuellement dans Amazon DynamoDB correspond `expectedVersion` exactement à l'argument. Lorsque l'élément est mis à jour, nous voulons augmenter la valeur du`version`. C'est facile à faire avec la fonction d'opération`increment`. Pour plus d'informations sur les expressions de condition, consultez la documentation sur les [expressions de condition](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). Pour plus d'informations sur la `UpdateItem` demande, consultez la [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)documentation et celle du [module DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html). Pour plus d'informations sur la façon d'écrire des expressions de mise à jour, consultez la documentation [ UpdateExpressionsDynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). ### Appelez l'API pour mettre à jour une publication Essayons de mettre à jour l'`Post`objet avec le nouveau résolveur. **Pour mettre à jour votre objet** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'`id`argument avec la valeur que vous avez notée précédemment : ``` mutation updatePost { updatePost( id:123 title: "An empty story" content: null expectedVersion: 1 ) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`updatePost`. 1. **La publication mise à jour dans Amazon DynamoDB doit apparaître dans **le** volet Résultats à droite du volet Requêtes.** Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "updatePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 2 } } } ``` Dans cette demande, vous avez demandé à Amazon DynamoDB de mettre à jour uniquement `title` les `content` champs AWS AppSync et. Tous les autres champs ont été laissés de côté (à l'exception de l'incrémentation du `version` champ). Vous avez défini une nouvelle valeur pour `title` l'attribut et vous l'`content`avez supprimé de la publication. Les champs `author`, `url`, `ups` et `downs` sont restés inchangés. Réessayez d'exécuter la demande de mutation en la laissant exactement telle quelle. La réponse devrait être similaire à ce qui suit : ``` { "data": { "updatePost": null }, "errors": [ { "path": [ "updatePost" ], "data": null, "errorType": "DynamoDB:ConditionalCheckFailedException", "errorInfo": null, "locations": [ { "line": 2, "column": 3, "sourceName": null } ], "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)" } ] } ``` La demande échoue car l'expression de condition est évaluée à `false` : 1. La première fois que vous avez exécuté la demande, la valeur du `version` champ de la publication dans Amazon DynamoDB `1` était, ce qui correspondait à l'argument. `expectedVersion` La demande a abouti, ce qui signifie que le `version` champ a été incrémenté dans Amazon DynamoDB à. `2` 1. La deuxième fois que vous avez exécuté la demande, la valeur du `version` champ de la publication dans Amazon DynamoDB `2` était, ce qui ne correspondait pas à l'argument. `expectedVersion` Ce modèle est généralement appelé *Verrouillage optimiste*. ## Création de mutations de vote (Amazon DynamoDB UpdateItem) Le `Post` type contient `ups` des `downs` champs permettant l'enregistrement des votes positifs et négatifs. Cependant, pour le moment, l'API ne nous permet pas de faire quoi que ce soit avec eux. Ajoutons une mutation pour nous permettre de voter pour et contre les publications. **Pour ajouter votre mutation** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le `Mutation` type et ajoutez l'`DIRECTION`énumération pour ajouter de nouvelles mutations de vote : ``` type Mutation { vote(id: ID!, direction: DIRECTION!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( id: ID, author: String!, title: String!, content: String!, url: String! ): Post! } enum DIRECTION { UP DOWN } ``` 1. Choisissez **Sauvegarder schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `vote` champ nouvellement créé sur le `Mutation` type, puis choisissez **Joindre**. Créez un nouveau résolveur en créant et en remplaçant le code par l'extrait suivant : ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const field = ctx.args.direction === 'UP' ? 'ups' : 'downs'; return ddb.update({ key: { id: ctx.args.id }, update: { [field]: ddb.operations.increment(1), version: ddb.operations.increment(1), }, }); } export const response = (ctx) => ctx.result; ``` 1. Enregistrez toutes les modifications que vous avez apportées. ### Appelez l'API pour voter pour ou contre une publication Maintenant que les nouveaux résolveurs ont été configurés, AWS AppSync il sait comment traduire une entrée `upvotePost` ou une `downvote` mutation en une opération Amazon DynamoDB`UpdateItem`. Vous pouvez désormais exécuter des mutations pour voter pour ou contre la publication que vous avez créée précédemment. **Pour exécuter votre mutation** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'`id`argument avec la valeur que vous avez notée précédemment : ``` mutation votePost { vote(id:123, direction: UP) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`votePost`. 1. **La publication mise à jour dans Amazon DynamoDB doit apparaître dans **le** volet Résultats à droite du volet Requêtes.** Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "vote": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 6, "downs": 0, "version": 4 } } } ``` 1. Choisissez **Exécuter** quelques fois de plus. Vous devriez voir les `version` champs `ups` et augmenter à `1` chaque fois que vous exécutez la requête. 1. Modifiez la requête pour l'appeler avec un nom différent`DIRECTION`. ``` mutation votePost { vote(id:123, direction: DOWN) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`votePost`. Cette fois, vous devriez voir les `version` champs `downs` et augmenter à `1` chaque fois que vous exécutez la requête. ## Configuration d'un résolveur DeletePost (Amazon DynamoDB) DeleteItem Ensuite, vous devez créer une mutation pour supprimer une publication. Pour ce faire, utilisez l'opération `DeleteItem` Amazon DynamoDB. **Pour ajouter votre mutation** 1. Dans votre schéma, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le `Mutation` type pour ajouter une nouvelle `deletePost` mutation : ``` type Mutation { deletePost(id: ID!, expectedVersion: Int): Post vote(id: ID!, direction: DIRECTION!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( id: ID author: String!, title: String!, content: String!, url: String! ): Post! } ``` 1. Cette fois, vous avez rendu le `expectedVersion` champ facultatif. Ensuite, choisissez **Enregistrer le schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `delete` champ nouvellement créé dans le `Mutation` type, puis choisissez **Joindre**. Créez un nouveau résolveur à l'aide du code suivant : ``` import { util } from '@aws-appsync/utils' import { util } from '@aws-appsync/utils'; import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { let condition = null; if (ctx.args.expectedVersion) { condition = { or: [ { id: { attributeExists: false } }, { version: { eq: ctx.args.expectedVersion } }, ], }; } return ddb.remove({ key: { id: ctx.args.id }, condition }); } export function response(ctx) { const { error, result } = ctx; if (error) { util.appendError(error.message, error.type); } return result; } ``` **Note** L'`expectedVersion`argument est facultatif. Si l'appelant définit un `expectedVersion` argument dans la demande, le gestionnaire de demandes ajoute une condition qui permet à la `DeleteItem` demande de réussir uniquement si l'article est déjà supprimé ou si l'`version`attribut de la publication dans Amazon DynamoDB correspond exactement au. `expectedVersion` En cas d'omission, aucune expression de condition n'est spécifiée dans la demande `DeleteItem`. Il réussit quelle que soit la valeur de l'élément `version` ou qu'il existe ou non dans Amazon DynamoDB. Même si vous supprimez un article, vous pouvez le renvoyer s'il ne l'a pas déjà été. Pour plus d'informations sur la `DeleteItem` demande, consultez la [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)documentation. ### Appelez l'API pour supprimer une publication Maintenant que le résolveur est configuré, AWS AppSync il sait comment traduire une `delete` mutation entrante en une opération Amazon DynamoDB`DeleteItem`. Vous pouvez désormais exécuter une mutation pour supprimer quelque chose dans la table. **Pour exécuter votre mutation** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'`id`argument avec la valeur que vous avez notée précédemment : ``` mutation deletePost { deletePost(id:123) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`deletePost`. 1. La publication est supprimée d'Amazon DynamoDB. **Notez que cela AWS AppSync renvoie la valeur de l'élément qui a été supprimé d'Amazon DynamoDB, qui doit apparaître dans **le** volet Résultats à droite du volet Requêtes.** Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "deletePost": { "id": "123", "author": "A new author", "title": "An empty story", "content": null, "url": "https://aws.amazon.com/appsync/", "ups": 6, "downs": 4, "version": 12 } } } ``` 1. La valeur n'est renvoyée que si cet appel à `deletePost` est celui qui la supprime réellement d'Amazon DynamoDB. Choisissez **à nouveau Exécuter**. 1. L'appel réussit toujours, mais aucune valeur n'est renvoyée : ``` { "data": { "deletePost": null } } ``` 1. Essayons maintenant de supprimer un message, mais cette fois en spécifiant un`expectedValue`. Tout d'abord, vous devez créer une nouvelle publication, car vous venez de supprimer celle sur laquelle vous avez travaillé jusqu'à présent. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante : ``` mutation addPost { addPost( id:123 author: "AUTHORNAME" title: "Our second post!" content: "A new post." url: "https://aws.amazon.com/appsync/" ) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`addPost`. 1. Les résultats de la publication nouvellement créée doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Enregistrez le `id` nom de l'objet nouvellement créé car vous en aurez besoin dans un instant. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "addPost": { "id": "123", "author": "AUTHORNAME", "title": "Our second post!", "content": "A new post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` 1. Essayons maintenant de supprimer cette publication avec une valeur illégale pour **ExpectedVersion**. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'`id`argument avec la valeur que vous avez notée précédemment : ``` mutation deletePost { deletePost( id:123 expectedVersion: 9999 ) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`deletePost`. Le résultat suivant est renvoyé : ``` { "data": { "deletePost": null }, "errors": [ { "path": [ "deletePost" ], "data": null, "errorType": "DynamoDB:ConditionalCheckFailedException", "errorInfo": null, "locations": [ { "line": 2, "column": 3, "sourceName": null } ], "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)" } ] } ``` 1. La demande a échoué car l'expression de condition est évaluée à`false`. La valeur `version` de la publication dans Amazon DynamoDB ne correspond pas à celle spécifiée dans `expectedValue` les arguments. La valeur actuelle de l'objet est renvoyée dans le champ `data` de la section `errors` de la réponse GraphQL. Réessayez la demande, mais corrigez `expectedVersion` : ``` mutation deletePost { deletePost( id:123 expectedVersion: 1 ) { id author title content url ups downs version } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`deletePost`. Cette fois, la demande aboutit et la valeur supprimée d'Amazon DynamoDB est renvoyée : ``` { "data": { "deletePost": { "id": "123", "author": "AUTHORNAME", "title": "Our second post!", "content": "A new post.", "url": "https://aws.amazon.com/appsync/", "ups": 1, "downs": 0, "version": 1 } } } ``` 1. Choisissez **à nouveau Exécuter**. L'appel réussit toujours, mais cette fois aucune valeur n'est renvoyée car la publication a déjà été supprimée dans Amazon DynamoDB. ``` { "data": { "deletePost": null } } ``` ## Configuration d'un résolveur AllPost (Amazon DynamoDB Scan) Jusqu'à présent, l'API n'est utile que si vous connaissez le `id` message que vous souhaitez consulter. Ajoutons un nouveau résolveur qui renvoie toutes les publications de la table. **Pour ajouter votre mutation** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le type `Query` pour ajouter une nouvelle requête `allPost` : ``` type Query { allPost(limit: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` 1. Ajouter un nouveau type `PaginationPosts` : ``` type PaginatedPosts { posts: [Post!]! nextToken: String } ``` 1. Choisissez **Sauvegarder schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `allPost` champ nouvellement créé dans le `Query` type, puis choisissez **Joindre**. Créez un nouveau résolveur avec le code suivant : ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 20, nextToken } = ctx.arguments; return ddb.scan({ limit, nextToken }); } export function response(ctx) { const { items: posts = [], nextToken } = ctx.result; return { posts, nextToken }; } ``` Le gestionnaire de requêtes de ce résolveur attend deux arguments facultatifs : + `limit`- Spécifie le nombre maximum d'éléments à renvoyer en un seul appel. + `nextToken`- Utilisé pour récupérer la prochaine série de résultats (nous montrerons d'où `nextToken` vient la valeur pour plus tard). 1. Enregistrez toutes les modifications apportées à votre résolveur. Pour plus d'informations sur la `Scan` demande, consultez la documentation de référence du [scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan). ### Appelez l'API pour scanner tous les posts Maintenant que le résolveur est configuré, AWS AppSync il sait comment traduire une `allPost` requête entrante en une opération Amazon DynamoDB`Scan`. Vous pouvez désormais analyser la table pour récupérer toutes les publications. Avant de pouvoir essayer, vous avez besoin de remplir la table avec certaines données, car vous avez supprimé tout ce que vous aviez utilisé jusque là. **Pour ajouter et interroger des données** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante : ``` mutation addPost { post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange). 1. Maintenant, analysons la table, en renvoyant cinq résultats à la fois. Dans le volet **Requêtes**, ajoutez la requête suivante : ``` query allPost { allPost(limit: 5) { posts { id title } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPost`. Les cinq premiers articles doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPost": { "posts": [ { "id": "5", "title": "A series of posts, Volume 5" }, { "id": "1", "title": "A series of posts, Volume 1" }, { "id": "6", "title": "A series of posts, Volume 6" }, { "id": "9", "title": "A series of posts, Volume 9" }, { "id": "7", "title": "A series of posts, Volume 7" } ], "nextToken": "" } } } ``` 1. Vous avez reçu cinq résultats et un `nextToken` que vous pouvez utiliser pour obtenir la prochaine série de résultats. Mettez à jour la requête `allPost` pour qu'elle inclue l'élément `nextToken` issu de l'ensemble de résultats précédent : ``` query allPost { allPost( limit: 5 nextToken: "" ) { posts { id author } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPost`. Les quatre publications restantes devraient apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il n'y en a pas `nextToken` dans cette série de résultats parce que vous avez parcouru les neuf articles et qu'il n'en reste aucun. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPost": { "posts": [ { "id": "2", "title": "A series of posts, Volume 2" }, { "id": "3", "title": "A series of posts, Volume 3" }, { "id": "4", "title": "A series of posts, Volume 4" }, { "id": "8", "title": "A series of posts, Volume 8" } ], "nextToken": null } } } ``` ## Configuration d'un résolveur d' allPostsByauteur (requête Amazon DynamoDB) Outre l'analyse de toutes les publications sur Amazon DynamoDB, vous pouvez également interroger Amazon DynamoDB pour récupérer les publications créées par un auteur spécifique. La table Amazon DynamoDB que vous avez créée précédemment possède déjà `GlobalSecondaryIndex` un `author-index` appel que vous pouvez utiliser avec une opération Amazon DynamoDB pour récupérer toutes les `Query` publications créées par un auteur spécifique. **Pour ajouter votre requête** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le type `Query` pour ajouter une nouvelle requête `allPostsByAuthor` : ``` type Query { allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts! allPost(limit: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` Notez que cela utilise le même `PaginatedPosts` type que celui que vous avez utilisé pour la `allPost` requête. 1. Choisissez **Sauvegarder schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `allPostsByAuthor` champ nouvellement créé sur le `Query` type, puis choisissez **Joindre**. Créez un résolveur à l'aide de l'extrait ci-dessous : ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 20, nextToken, author } = ctx.arguments; return ddb.query({ index: 'author-index', query: { author: { eq: author } }, limit, nextToken, }); } export function response(ctx) { const { items: posts = [], nextToken } = ctx.result; return { posts, nextToken }; } ``` Comme le `allPost` résolveur, ce résolveur possède deux arguments facultatifs : + `limit`- Spécifie le nombre maximum d'éléments à renvoyer en un seul appel. + `nextToken`- Récupère le prochain ensemble de résultats (la valeur de `nextToken` peut être obtenue à partir d'un appel précédent). 1. Enregistrez toutes les modifications apportées à votre résolveur. Pour plus d'informations sur la `Query` demande, consultez la documentation de référence sur les [requêtes](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-query). ### Appelez l'API pour interroger tous les articles par auteur Maintenant que le résolveur a été configuré, AWS AppSync il sait comment traduire une `allPostsByAuthor` mutation entrante en une opération `Query` DynamoDB par rapport à l'index. `author-index` Vous pouvez désormais interroger la table pour récupérer toutes les publications d'un auteur spécifique. Avant cela, cependant, remplissons le tableau avec quelques articles supplémentaires, car tous les articles ont jusqu'à présent le même auteur. **Pour ajouter des données et effectuer une requête** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante : ``` mutation addPost { post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title } post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title } post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`addPost`. 1. Maintenant, interrogez la table et renvoyez toutes les publications créées par `Nadia`. Dans le volet **Requêtes**, ajoutez la requête suivante : ``` query allPostsByAuthor { allPostsByAuthor(author: "Nadia") { posts { id title } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPostsByAuthor`. Toutes les publications rédigées par `Nadia` doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "10", "title": "The cutest dog in the world" }, { "id": "11", "title": "Did you know...?" } ], "nextToken": null } } } ``` 1. La pagination fonctionne pour `Query` tout comme elle le fait pour `Scan`. Par exemple, examinons toutes les publications créées par `AUTHORNAME`, et prenons-en cinq à la fois. 1. Dans le volet **Requêtes**, ajoutez la requête suivante : ``` query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" limit: 5 ) { posts { id title } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPostsByAuthor`. Toutes les publications rédigées par `AUTHORNAME` doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "6", "title": "A series of posts, Volume 6" }, { "id": "4", "title": "A series of posts, Volume 4" }, { "id": "2", "title": "A series of posts, Volume 2" }, { "id": "7", "title": "A series of posts, Volume 7" }, { "id": "1", "title": "A series of posts, Volume 1" } ], "nextToken": "" } } } ``` 1. Mettez à jour l'argument `nextToken` avec la valeur renvoyée par la requête précédente : ``` query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" limit: 5 nextToken: "" ) { posts { id title } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPostsByAuthor`. Les autres publications rédigées par `AUTHORNAME` doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "8", "title": "A series of posts, Volume 8" }, { "id": "5", "title": "A series of posts, Volume 5" }, { "id": "3", "title": "A series of posts, Volume 3" }, { "id": "9", "title": "A series of posts, Volume 9" } ], "nextToken": null } } } ``` ## Utiliser des ensembles Jusqu'à présent, le `Post` type était un key/value objet plat. Vous pouvez également modéliser des objets complexes avec votre résolveur, tels que des ensembles, des listes et des cartes. Mettons à jour notre type `Post` pour inclure des balises. Une publication peut comporter zéro ou plusieurs balises, qui sont stockées dans DynamoDB sous forme de jeu de chaînes. Vous allez également configurer certaines mutations pour ajouter et supprimer des balises, et une nouvelle requête pour rechercher des publications avec une balise spécifique. **Pour configurer vos données** 1. Dans votre API, choisissez l'onglet **Schéma**. 1. Dans le volet **Schéma**, modifiez le type `Post` pour ajouter un nouveau champ `tags` : ``` type Post { id: ID! author: String title: String content: String url: String ups: Int! downs: Int! version: Int! tags: [String!] } ``` 1. Dans le volet **Schéma**, modifiez le type `Query` pour ajouter une nouvelle requête `allPostsByTag` : ``` type Query { allPostsByTag(tag: String!, limit: Int, nextToken: String): PaginatedPosts! allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts! allPost(limit: Int, nextToken: String): PaginatedPosts! getPost(id: ID): Post } ``` 1. Dans le volet **Schéma**, modifiez le type `Mutation` pour ajouter de nouvelles mutations `addTag` et `removeTag` : ``` type Mutation { addTag(id: ID!, tag: String!): Post removeTag(id: ID!, tag: String!): Post deletePost(id: ID!, expectedVersion: Int): Post upvotePost(id: ID!): Post downvotePost(id: ID!): Post updatePost( id: ID!, author: String, title: String, content: String, url: String, expectedVersion: Int! ): Post addPost( author: String!, title: String!, content: String!, url: String! ): Post! } ``` 1. Choisissez **Sauvegarder schéma**. 1. Dans le volet **Résolveurs** sur la droite, recherchez le `allPostsByTag` champ nouvellement créé sur le `Query` type, puis choisissez **Joindre**. Créez votre résolveur à l'aide de l'extrait ci-dessous : ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 20, nextToken, tag } = ctx.arguments; return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } }); } export function response(ctx) { const { items: posts = [], nextToken } = ctx.result; return { posts, nextToken }; } ``` 1. Enregistrez toutes les modifications que vous avez apportées à votre résolveur. 1. Maintenant, faites de même pour le `Mutation` champ `addTag` en utilisant l'extrait ci-dessous : **Note** Bien que les utilitaires DynamoDB ne prennent actuellement pas en charge les opérations relatives aux ensembles, vous pouvez toujours interagir avec les ensembles en créant vous-même la requête. ``` import { util } from '@aws-appsync/utils' export function request(ctx) { const { id, tag } = ctx.arguments const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 }) expressionValues[':tags'] = util.dynamodb.toStringSet([tag]) return { operation: 'UpdateItem', key: util.dynamodb.toMapValues({ id }), update: { expression: `ADD tags :tags, version :plusOne`, expressionValues, }, } } export const response = (ctx) => ctx.result ``` 1. Enregistrez toutes les modifications apportées à votre résolveur. 1. Répétez cette opération une fois de plus pour le `Mutation` champ `removeTag` à l'aide de l'extrait ci-dessous : ``` import { util } from '@aws-appsync/utils'; export function request(ctx) { const { id, tag } = ctx.arguments; const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 }); expressionValues[':tags'] = util.dynamodb.toStringSet([tag]); return { operation: 'UpdateItem', key: util.dynamodb.toMapValues({ id }), update: { expression: `DELETE tags :tags ADD version :plusOne`, expressionValues, }, }; } export const response = (ctx) => ctx.resultexport ``` 1. Enregistrez toutes les modifications apportées à votre résolveur. ### Appel de l'API pour utiliser des balises Maintenant que vous avez configuré les résolveurs, vous savez comment AWS AppSync traduire les requêtes entrantes et `addTag` les `removeTag` `allPostsByTag` requêtes en `UpdateItem` DynamoDB `Scan` et en opérations. Pour tester cela, sélectionnons l'une des publications que nous avons créées précédemment. Par exemple, utilisons un article créé par `Nadia`. **Pour utiliser des balises** 1. Dans votre API, choisissez l'onglet **Requêtes**. 1. Dans le volet **Requêtes**, ajoutez la requête suivante : ``` query allPostsByAuthor { allPostsByAuthor( author: "Nadia" ) { posts { id title } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPostsByAuthor`. 1. Toutes les publications de Nadia doivent apparaître dans le volet **Résultats** à droite du volet **Requêtes**. Il doit ressembler à l’exemple ci-dessous. ``` { "data": { "allPostsByAuthor": { "posts": [ { "id": "10", "title": "The cutest dog in the world" }, { "id": "11", "title": "Did you known...?" } ], "nextToken": null } } } ``` 1. Utilisons celui qui s'intitule Le *chien le plus mignon du monde.* Enregistrez-le `id` car vous l'utiliserez plus tard. Essayons maintenant d'ajouter un `dog` tag. 1. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'argument `id` pour qu'il ait la valeur que vous avez notée précédemment. ``` mutation addTag { addTag(id:10 tag: "dog") { id title tags } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`addTag`. Le message est mis à jour avec le nouveau tag : ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } } ``` 1. Vous pouvez ajouter d'autres tags. Mettez à jour la mutation pour remplacer l'`tag`argument par `puppy` : ``` mutation addTag { addTag(id:10 tag: "puppy") { id title tags } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`addTag`. Le message est mis à jour avec le nouveau tag : ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog", "puppy" ] } } } ``` 1. Vous pouvez également supprimer des balises. Dans le volet **Requêtes**, ajoutez la mutation suivante. Vous devrez également mettre à jour l'`id`argument avec la valeur que vous avez notée précédemment : ``` mutation removeTag { removeTag(id:10 tag: "puppy") { id title tags } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`removeTag`. La publication est mise à jour et la balise `puppy` est supprimée. ``` { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } } ``` 1. Vous pouvez également rechercher tous les articles comportant un tag. Dans le volet **Requêtes**, ajoutez la requête suivante : ``` query allPostsByTag { allPostsByTag(tag: "dog") { posts { id title tags } nextToken } } ``` 1. Choisissez **Exécuter** (le bouton de lecture orange), puis choisissez`allPostsByTag`. Toutes les publications qui ont la balise `dog` sont renvoyées : ``` { "data": { "allPostsByTag": { "posts": [ { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog", "puppy" ] } ], "nextToken": null } } } ``` ## Conclusion Dans ce didacticiel, vous avez créé une API qui vous permet de manipuler des `Post` objets dans DynamoDB à l'aide de AWS AppSync GraphQL. Pour nettoyer, vous pouvez supprimer l'API AWS AppSync GraphQL de la console. **Pour supprimer le rôle associé à votre table DynamoDB, sélectionnez votre source de données dans **le tableau Sources de données et cliquez sur** Modifier.** Notez la valeur du rôle sous **Créer ou utiliser un rôle existant**. Accédez à la console IAM pour supprimer le rôle. Pour supprimer votre table DynamoDB, cliquez sur le nom de la table dans la liste des sources de données. Cela vous amène à la console DynamoDB où vous pouvez supprimer la table.