Configuration de vos tables DynamoDB Création de votre GraphQL API Définition d'un article de base API Configuration de la source de données pour les tables DynamoDB Configuration du addPost résolveur ( PutItemDynamoDB)Configuration du getPost résolveur ( GetItemDynamoDB)Création d'une updatePost mutation (DynamoDB) UpdateItem Modification du updatePost résolveur ( UpdateItemDynamoDB)Création upvotePost et downvotePost mutations (DynamoDB) UpdateItem Configuration du deletePost résolveur ( DeleteItemDynamoDB)Configuration du allPost résolveur (DynamoDB Scan)Configuration du résolveur d' allPostsByauteur (requête DynamoDB)Utilisation des ensembles Utilisation de listes et de cartes Conclusion

Création d'une post-application simple à l'aide des résolveurs DynamoDB

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.

Ce didacticiel explique comment importer vos propres tables Amazon DynamoDB et comment les connecter AWS AppSync à un GraphQL. API

Vous pouvez autoriser le AWS AppSync provisionnement des ressources DynamoDB en votre nom. Ou, si vous préférez, vous pouvez connecter vos tables existantes à un schéma GraphQL en créant une source de données et un résolveur. Dans les deux cas, vous serez en mesure de lire et d'écrire dans votre base de données DynamoDB via les instructions GraphQL, et de vous abonner aux données en temps réel.

Certaines étapes de configuration spécifiques doivent être effectuées pour convertir des instructions GraphQL en opérations DynamoDB, et pour reconvertir les réponses 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.

Configuration de vos tables DynamoDB

Pour commencer ce didacticiel, vous devez d'abord suivre les étapes ci-dessous pour provisionner AWS les ressources.

Provisionnez AWS des ressources à l'aide du AWS CloudFormation modèle suivant dans le CLI :
```
aws cloudformation create-stack \
    --stack-name AWSAppSyncTutorialForAmazonDynamoDB \
    --template-url https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml \
    --capabilities CAPABILITY_NAMED_IAM
```
Vous pouvez également lancer la AWS CloudFormation pile suivante dans la région US-West 2 (Oregon) sur votre AWS compte.

Cela crée les éléments suivants :
- Une table DynamoDB AppSyncTutorial-Post appelée qui contiendra les données. Post
- Un IAM rôle et une politique IAM gérée associée permettant AWS AppSync d'interagir avec la Post table.
Pour obtenir plus de détails sur la pile et les ressources créées, exécutez la CLI commande suivante :
```
aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```

Pour supprimer ultérieurement les ressources, vous pouvez exécuter :


aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB

Création de votre GraphQL API

Pour créer le GraphQL API dans : AWS AppSync

Connectez-vous à la AppSync console AWS Management Console et ouvrez-la.
1. Dans le APIstableau de bord, choisissez Create API.
Dans la fenêtre Personnaliser API ou importer depuis Amazon DynamoDB, choisissez Créer à partir de zéro.
1. Choisissez Démarrer à droite de la même fenêtre.
Dans le champ APINom, définissez le nom du API àAWSAppSyncTutorial.
Sélectionnez Create (Créer).

La AWS AppSync console crée un nouveau GraphQL API pour vous en utilisant le mode d'authentification par API clé. Vous pouvez utiliser la console pour configurer le reste de GraphQL API et exécuter des requêtes sur celui-ci pour le reste de ce didacticiel.

Définition d'un article de base API

Maintenant que vous avez créé un AWS AppSync GraphQLAPI, 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.

Connectez-vous à la AppSync console AWS Management Console et ouvrez-la.
1. Dans le APIstableau de bord, choisissez le API que vous venez de créer.

Dans la barre latérale, choisissez Schema.

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!
}

Choisissez Save (Enregistrer).

Ce schéma définit un type Post et des opérations pour ajouter et obtenir des objets Post.

Configuration de la source de données pour les tables DynamoDB

Liez ensuite les requêtes et les mutations définies dans le schéma à la table AppSyncTutorial-Post DynamoDB.

Tout d' AWS AppSync abord, vous devez connaître vos tables. Pour ce faire, configurez une source de données dans AWS AppSync :

Connectez-vous à la AppSync console AWS Management Console et ouvrez-la.
1. Dans le APIstableau de bord, choisissez votre GraphQLAPI.
2. Dans la barre latérale, sélectionnez Sources de données.
Choisissez Create data source.
1. Dans le champ Nom de la source de données, entrezPostDynamoDBTable.
2. Pour le type de source de données, choisissez la table Amazon DynamoDB.
3. Pour Région, choisissez US- WEST -2.
4. Pour Nom de la table, choisissez la table AppSyncTutorialDynamoDB -Post.
5. Créez un nouveau IAM rôle (recommandé) ou choisissez un rôle existant lambda:invokeFunction IAM autorisé. Les rôles existants nécessitent une politique de confiance, comme expliqué dans la section Joindre une source de données.
  
  Voici un exemple de IAM politique qui dispose des autorisations requises pour effectuer des opérations sur la ressource :
```
{ 
     "Version": "2012-10-17", 
     "Statement": [ 
         { 
             "Effect": "Allow", 
             "Action": [ "lambda:invokeFunction" ], 
             "Resource": [ 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction", 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*" 
             ] 
         } 
     ] 
 }
```
Sélectionnez Create (Créer).

Configuration du addPost résolveur ( PutItemDynamoDB)

Une fois AWS AppSync que vous avez pris connaissance de la table 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 addPost résolveur, qui vous permet de créer une publication dans la table DynamoDBAppSyncTutorial-Post.

Un résolveur comprend les éléments suivants :

L'emplacement dans le schéma GraphQL pour joindre le résolveur. Dans ce cas, vous configurez un résolveur sur le champ addPost sur le type Mutation. Ce résolveur est appelé lorsque l'appelant appelle mutation { addPost(...){...} }.
La source de données à utiliser pour ce résolveur. Dans ce cas, vous souhaitez utiliser la source de données PostDynamoDBTable que vous avez définie précédemment, afin de pouvoir ajouter des entrées dans la table DynamoDB AppSyncTutorial-Post.
Le modèle de mappage de demande. L'objectif du modèle de mappage des demandes est de prendre la demande entrante de l'appelant et de la traduire en instructions AWS AppSync à exécuter par rapport à DynamoDB.
Le modèle de mappage de réponse. La tâche du modèle de mappage de réponse est de prendre la réponse provenant de DynamoDB et de la reconvertir en quelque chose que GraphQL attend. 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 le résolveur :

Connectez-vous à la AppSync console AWS Management Console et ouvrez-la.
1. Dans le APIstableau de bord, choisissez votre GraphQLAPI.
2. Dans la barre latérale, sélectionnez Sources de données.
Choisissez Create data source.
1. Dans le champ Nom de la source de données, entrezPostDynamoDBTable.
2. Pour le type de source de données, choisissez la table Amazon DynamoDB.
3. Pour Région, choisissez US- WEST -2.
4. Pour Nom de la table, choisissez la table AppSyncTutorialDynamoDB -Post.
5. Créez un nouveau IAM rôle (recommandé) ou choisissez un rôle existant lambda:invokeFunction IAM autorisé. Les rôles existants nécessitent une politique de confiance, comme expliqué dans la section Joindre une source de données.
  
  Voici un exemple de IAM politique qui dispose des autorisations requises pour effectuer des opérations sur la ressource :
```
{ 
     "Version": "2012-10-17", 
     "Statement": [ 
         { 
             "Effect": "Allow", 
             "Action": [ "lambda:invokeFunction" ], 
             "Resource": [ 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction", 
                 "arn:aws:lambda:us-west-2:123456789012:function:myFunction:*" 
             ] 
         } 
     ] 
 }
```
Sélectionnez Create (Créer).
Choisissez l'onglet Schéma.
Dans le volet Types de données sur la droite, recherchez le addPostchamp correspondant au type de mutation, puis choisissez Attacher.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.
Collez ce qui suit dans la section Configurer le modèle de mappage de demande :
```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "attributeValues" : {
        "author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
        "title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
        "content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
        "url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
        "ups" : { "N" : 1 },
        "downs" : { "N" : 0 },
        "version" : { "N" : 1 }
    }
}
```
Remarque : un type est spécifié sur toutes les clés et valeurs d'attribut. Par exemple, vous définissez le champ author sur { "S" : "${context.arguments.author}" }. La S partie indique à DynamoDB AWS AppSync et à DynamoDB que la valeur sera une valeur de chaîne. La valeur réelle est renseignée à partir de l'argument author. De la même façon, le champ version est un champ numérique, car il utilise N comme type. Enfin, vous initialisez également les champs ups, downs et version.

Pour ce didacticiel, vous avez indiqué que le ID! type GraphQL, qui indexe le nouvel élément inséré dans DynamoDB, fait partie des arguments du client. AWS AppSync est livré avec un utilitaire de génération automatique d'identifiants appelé $utils.autoId() que vous auriez également pu utiliser sous la forme de"id" : { "S" : "${$utils.autoId()}" }. Ensuite, vous pourriez simplement laisser id: ID! hors de la définition de schéma de addPost() et il serait inséré automatiquement. Vous n'utiliserez pas cette technique dans ce didacticiel, mais vous devez la considérer comme une bonne pratique lorsque vous écrivez dans des tables DynamoDB.

Pour plus d'informations sur les modèles de mappage, consultez la documentation de référence Présentation des modèles de mappage des résolveurs. Pour plus d'informations sur le mappage des GetItem demandes, consultez la documentation de GetItemréférence. Pour plus d'informations sur les types, consultez la documentation de référence Système de types (mappage de demande).
Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Remarque : comme la forme des données de la table AppSyncTutorial-Post correspond exactement à la forme du type Post dans GraphQL, le modèle de mappage de réponse transmet simplement directement les résultats. Notez également que tous les exemples utilisés dans ce tutoriel utilisent le même modèle de mappage de réponse, si bien que vous ne créez qu'un fichier.
Choisissez Save (Enregistrer).

Appelez le API pour ajouter un message

Maintenant que le résolveur est configuré, il AWS AppSync peut traduire une addPost mutation entrante en une opération DynamoDB PutItem . Vous pouvez désormais exécuter une mutation pour placer quelque chose dans la table.

Choisissez l'onglet Requêtes.

Collez la mutation suivante dans le volet Requêtes.


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
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Les résultats de la publication nouvellement créée doivent apparaître dans le volet des résultats à droite du volet de requête. 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
    }
  }
}

Voici ce qui s'est produit :

AWS AppSync a reçu une demande de addPost mutation.

AWS AppSync a pris la demande et le modèle de mappage des demandes, et a généré un document de mappage des demandes. Celui-ci ressemblait à :


{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key" : {
        "id" : { "S" : "123" }
    },
    "attributeValues" : {
        "author": { "S" : "AUTHORNAME" },
        "title": { "S" : "Our first post!" },
        "content": { "S" : "This is our first post." },
        "url": { "S" : "https://aws.amazon.com/appsync/" },
        "ups" : { "N" : 1 },
        "downs" : { "N" : 0 },
        "version" : { "N" : 1 }
    }
}

AWS AppSync a utilisé le document de mappage des demandes pour générer et exécuter une demande PutItem DynamoDB.

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
}

Ils ont été transmis via le document de mappage de réponse, qui les a transmis sans les changer.
L'objet nouvellement créé a été renvoyé dans la réponse GraphQL.

Configuration du getPost résolveur ( GetItemDynamoDB)

Maintenant que vous pouvez ajouter des données à la table AppSyncTutorial-Post DynamoDB, vous devez configurer getPost la requête afin qu'elle puisse extraire ces données de la table. AppSyncTutorial-Post Pour ce faire, vous configurez un autre résolveur.

Choisissez l'onglet Schéma.
Dans le volet Types de données sur la droite, recherchez le getPostchamp correspondant au type de requête, puis choisissez Joindre.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).

Appelez le 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 DynamoDBGetItem. Vous pouvez désormais exécuter une requête pour récupérer la publication que vous avez créée précédemment.

Choisissez l'onglet Requêtes.

Collez ce qui suit dans le volet Requêtes :


query getPost {
  getPost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

La publication extraite de DynamoDB doit apparaître dans le volet des résultats à droite du volet des 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
    }
  }
}

Voici ce qui s'est produit :

AWS AppSync a reçu une demande de getPost requête.
AWS AppSync a pris la demande et le modèle de mappage des demandes, et a généré un document de mappage des demandes. Celui-ci ressemblait à :
```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "123" }
    }
}
```
AWS AppSync a utilisé le document de mappage des demandes pour générer et exécuter une demande GetItem DynamoDB.

AWS AppSync a pris les résultats de la GetItem 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
}

Ils ont été transmis via le document de mappage de réponse, qui les a transmis sans les changer.
L'objet récupéré a été renvoyé dans la réponse.

Vous pouvez également prendre l'exemple suivant :


query getPost {
  getPost(id:123) {
    id
    author
    title
  }
}

Si votre getPost requête n'a besoin que duid, et authortitle, vous pouvez modifier votre modèle de mappage de demandes 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, le modèle de mappage des demandes peut ressembler à l'extrait ci-dessous :


{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "projection" : {
     "expression" : "#author, id, title",
     "expressionNames" : { "#author" : "author"}
    }
}

Création d'une updatePost mutation (DynamoDB) UpdateItem

Jusqu'à présent, vous pouvez créer et récupérer Post des objets dans DynamoDB. Ensuite, vous allez configurer une nouvelle mutation pour pouvoir mettre à jour l'objet. Pour ce faire, utilisez l'opération UpdateItem DynamoDB.

Choisissez l'onglet Schéma.

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!
    ): Post
    addPost(
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le updatePostchamp nouvellement créé sur le type de mutation, puis choisissez Attacher.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.
Collez ce qui suit dans la section Configurer le modèle de mappage de demande :
```
{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "SET author = :author, title = :title, content = :content, #url = :url ADD version :one",
        "expressionNames": {
            "#url" : "url"
        },
        "expressionValues": {
            ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author),
            ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title),
            ":content" : $util.dynamodb.toDynamoDBJson($context.arguments.content),
            ":url" : $util.dynamodb.toDynamoDBJson($context.arguments.url),
            ":one" : { "N": 1 }
        }
    }
}
```
Remarque : Ce résolveur utilise le UpdateItem DynamoDB, qui est très différent de l'opération. PutItem Au lieu d'écrire l'élément dans son intégralité, vous demandez simplement à DynamoDB de mettre à jour certains attributs. Cela se fait à l'aide des expressions de mise à jour DynamoDB. L'expression elle-même est spécifiée dans le champ expression de la section update. Elle indique de définir les attributs author, title, content et URL, puis d'incrémenter le champ version. Les valeurs à utiliser n'apparaissent pas dans l'expression elle-même ; l'expression a des espaces réservés qui ont des noms qui commencent par deux points et qui sont ensuite définis dans le champ expressionValues. Enfin, DynamoDB a réservé des mots qui ne peuvent pas apparaître dans le. expression Par exemple, url est un mot réservé, si bien que pour mettre à jour le champ url, vous pouvez utiliser des espaces réservés de nom et les définir dans le champ expressionNames.

Pour plus d'informations sur le mappage des UpdateItem demandes, consultez la documentation de UpdateItemréférence. Pour plus d'informations sur la façon d'écrire des expressions de mise à jour, consultez la documentation UpdateExpressions DynamoDB.
Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```

Appelez le API pour mettre à jour une publication

Maintenant que le résolveur est configuré, AWS AppSync il sait comment traduire une update mutation entrante en une opération DynamoDBUpdate. Vous pouvez désormais exécuter une mutation pour mettre à jour l'élément que vous avez écrit précédemment.

Choisissez l'onglet Requêtes.

Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait la valeur que vous avez notée précédemment.


mutation updatePost {
  updatePost(
    id:"123"
    author: "A new author"
    title: "An updated author!"
    content: "Now with updated content!"
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

La publication mise à jour dans DynamoDB doit apparaître dans le volet des résultats à droite du volet des requêtes. Il doit ressembler à l'exemple ci-dessous.


{
  "data": {
    "updatePost": {
      "id": "123",
      "author": "A new author",
      "title": "An updated author!",
      "content": "Now with updated content!",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 2
    }
  }
}

Dans cet exemple, les downs champs ups et n'ont pas été modifiés car le modèle de mappage des demandes n'a pas demandé à AWS AppSync DynamoDB de faire quoi que ce soit avec ces champs. De plus, le version champ a été incrémenté de 1 parce que vous avez demandé AWS AppSync à DynamoDB d'ajouter 1 au champ. version

Modification du updatePost résolveur ( UpdateItemDynamoDB)

Il s'agit d'un bon début pour la mutation updatePost, mais elle comporte deux problèmes principaux :

Si vous souhaitez mettre à jour un seul champ, vous devez mettre à jour tous les champs.
Si deux personnes modifient l'objet, des informations risquent d'être perdues.

Pour résoudre ces problèmes, vous allez modifier la mutation updatePost pour modifier uniquement les arguments qui ont été spécifiés dans la demande, puis ajouter une condition à l'opération UpdateItem.

Choisissez l'onglet Schéma.

Dans le volet Schéma, modifiez le champ updatePost dans le type Mutation pour supprimer les points d'exclamation des arguments author, title, content, et url, en veillant à laisser le champ id en l'état. Cela rend ces arguments facultatifs. En outre, ajoutez un nouvel argument expectedVersion requis.


type Mutation {
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le updatePostchamp correspondant au type de mutation.
Choisissez PostDynamoDBTabled'ouvrir le résolveur existant.

Modifiez le modèle de mappage de demande dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },

    ## Set up some space to keep track of things you're updating **
    #set( $expNames  = {} )
    #set( $expValues = {} )
    #set( $expSet = {} )
    #set( $expAdd = {} )
    #set( $expRemove = [] )

    ## Increment "version" by 1 **
    $!{expAdd.put("version", ":one")}
    $!{expValues.put(":one", { "N" : 1 })}

    ## Iterate through each argument, skipping "id" and "expectedVersion" **
    #foreach( $entry in $context.arguments.entrySet() )
        #if( $entry.key != "id" && $entry.key != "expectedVersion" )
            #if( (!$entry.value) && ("$!{entry.value}" == "") )
                ## If the argument is set to "null", then remove that attribute from the item in DynamoDB **

                #set( $discard = ${expRemove.add("#${entry.key}")} )
                $!{expNames.put("#${entry.key}", "$entry.key")}
            #else
                ## Otherwise set (or update) the attribute on the item in DynamoDB **

                $!{expSet.put("#${entry.key}", ":${entry.key}")}
                $!{expNames.put("#${entry.key}", "$entry.key")}
                $!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
            #end
        #end
    #end

    ## Start building the update expression, starting with attributes you're going to SET **
    #set( $expression = "" )
    #if( !${expSet.isEmpty()} )
        #set( $expression = "SET" )
        #foreach( $entry in $expSet.entrySet() )
            #set( $expression = "${expression} ${entry.key} = ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes you're going to ADD **
    #if( !${expAdd.isEmpty()} )
        #set( $expression = "${expression} ADD" )
        #foreach( $entry in $expAdd.entrySet() )
            #set( $expression = "${expression} ${entry.key} ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes you're going to REMOVE **
    #if( !${expRemove.isEmpty()} )
        #set( $expression = "${expression} REMOVE" )

        #foreach( $entry in $expRemove )
            #set( $expression = "${expression} ${entry}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
    "update" : {
        "expression" : "${expression}"
        #if( !${expNames.isEmpty()} )
            ,"expressionNames" : $utils.toJson($expNames)
        #end
        #if( !${expValues.isEmpty()} )
            ,"expressionValues" : $utils.toJson($expValues)
        #end
    },

    "condition" : {
        "expression"       : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
        }
    }
}

Choisissez Save (Enregistrer).

Ce modèle est l'un des exemples les plus complexes. Il illustre la puissance et la flexibilité des modèles de mappage. Il passe en revue tous les arguments, en faisant l'impasse sur id et expectedVersion. Si l'argument est défini sur quelque chose, il demande AWS AppSync à DynamoDB de mettre à jour cet attribut sur l'objet dans DynamoDB. Si l'attribut est défini sur null, il demande AWS AppSync à DynamoDB de le supprimer de l'objet de publication. Si un argument n'a pas été spécifié, il laisse l'attribut. Il incrémente également le champ version.

Il existe également une nouvelle section condition. Une expression de condition vous permet de dire AWS AppSync à DynamoDB si la demande doit aboutir ou non en fonction de l'état de l'objet déjà présent dans DynamoDB avant l'exécution de l'opération. Dans ce cas, vous souhaitez que la UpdateItem demande aboutisse uniquement si le version champ de l'élément actuellement dans DynamoDB correspond exactement à l'argument. expectedVersion

Pour plus d'informations sur les expressions de condition, consultez la documentation de référence Expressions de condition.

Appelez le API pour mettre à jour une publication

Essayons de mettre à jour l'objet Post avec le nouveau résolveur :

Choisissez l'onglet Requêtes.

Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait la valeur que vous avez notée précédemment.


mutation updatePost {
  updatePost(
    id:123
    title: "An empty story"
    content: null
    expectedVersion: 2
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

La publication mise à jour dans DynamoDB doit apparaître dans le volet des résultats à droite du volet des 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": 3
    }
  }
}

Dans cette demande, vous avez demandé à DynamoDB de mettre à jour title le content champ AWS AppSync et uniquement. Cela a laissé seuls tous les autres champs (autres que l'incrémentation du champ version). Vous avez défini l'attribut title sur une nouvelle valeur et avons supprimé l'attribut content de la publication. Les champs author, url, ups et downs sont restés inchangés.

Essayez d'exécuter une nouvelle fois la demande de mutation en laissant la demande exactement telle quelle. La réponse devrait être similaire à ce qui suit :


{
  "data": {
    "updatePost": null
  },
  "errors": [
    {
      "path": [
        "updatePost"
      ],
      "data": {
        "id": "123",
        "author": "A new author",
        "title": "An empty story",
        "content": null,
        "url": "https://aws.amazon.com/appsync/",
        "ups": 1,
        "downs": 0,
        "version": 3
      },
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
    }
  ]
}

La demande échoue, car l'expression de condition prend la valeur false :

La première fois que vous avez exécuté la demande, la valeur du version champ de la publication dans DynamoDB 2 était, qui correspondait à l'argument. expectedVersion La demande a abouti, ce qui signifie que le version champ a été incrémenté dans DynamoDB à. 3
La deuxième fois que vous avez exécuté la demande, la valeur du version champ de la publication dans DynamoDB 3 était, ce qui ne correspondait pas à l'argument. expectedVersion

Ce modèle est généralement appelé Verrouillage optimiste.

L'une des fonctionnalités d'un résolveur AWS AppSync DynamoDB est qu'il renvoie la valeur actuelle de l'objet de publication dans DynamoDB. Vous pouvez trouver cette valeur dans le champ data de la section errors de la réponse GraphQL. Votre application peut utiliser ces informations pour déterminer la façon dont elle doit continuer. Dans ce cas, vous pouvez voir que le version champ de l'objet dans DynamoDB est défini sur. Vous pouvez donc simplement mettre 3 à jour expectedVersion l'argument 3 pour que la demande aboutisse à nouveau.

Consultez la documentation de référence sur le modèle de mappage Expressions de condition pour obtenir plus d'informations sur la gestion des échecs de vérification de condition.

Création upvotePost et downvotePost mutations (DynamoDB) UpdateItem

Le Post type comporte ups des downs champs pour permettre d'enregistrer les votes positifs et négatifs, mais jusqu'à présent, API il ne nous permet rien d'en faire. Permet d'ajouter certaines mutations pour nous laisser voter pour ou contre les publications.

Choisissez l'onglet Schéma.

Dans le volet Schéma, modifiez le type Mutation pour ajouter de nouvelles mutations upvotePost et downvotePost :


type Mutation {
    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!
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le upvotePostchamp nouvellement créé sur le type de mutation, puis choisissez Attacher.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD ups :plusOne, version :plusOne",
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, se trouve le champ downvotePost qui vient d'être créé, sur le type Mutation, choisissez ensuite Joindre.
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD downs :plusOne, version :plusOne",
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).

Appelez le API pour voter pour ou contre un post

Maintenant que les nouveaux résolveurs ont été configurés, ils AWS AppSync savent comment traduire une opération entrante upvotePost ou une downvote mutation en opération 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.

Choisissez l'onglet Requêtes.
Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait la valeur que vous avez notée précédemment.
```
mutation votePost {
  upvotePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Choisissez Exécuter une requête (le bouton de lecture orange).

La publication est mise à jour dans DynamoDB et doit apparaître dans le volet des résultats à droite du volet des requêtes. Il doit ressembler à l'exemple ci-dessous.


{
  "data": {
    "upvotePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 0,
      "version": 4
    }
  }
}

Choisissez Exécuter une requête quelque fois de plus. Vous devez voir le champ ups et version être incrémenté de 1 chaque fois que vous exécutez la requête.

Modifiez la requête pour appeler la mutation downvotePost :


mutation votePost {
  downvotePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange). Cette fois, vous devez voir le champ downs et version être incrémenté de 1 chaque fois que vous exécutez la requête.


{
  "data": {
    "downvotePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 4,
      "version": 12
    }
  }
}

Configuration du deletePost résolveur ( DeleteItemDynamoDB)

La prochaine mutation que vous allez configurer permettra de supprimer une publication. Pour ce faire, utilisez l'opération DeleteItem DynamoDB.

Choisissez l'onglet Schéma.

Dans le volet Schéma, modifiez le type Mutation pour ajouter une nouvelle mutation deletePost :


type Mutation {
    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!
}

Cette fois vous avez rendu le champ expectedVersion facultatif, ce qui est expliqué plus loin lorsque vous ajoutez le modèle de mappage de demande.

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, se trouve le champ delete qui vient d'être créé, sur le type Mutation, choisissez ensuite Joindre.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.
Collez ce qui suit dans la section Configurer le modèle de mappage de demande :
```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key": {
        "id": $util.dynamodb.toDynamoDBJson($context.arguments.id)
    }
    #if( $context.arguments.containsKey("expectedVersion") )
        ,"condition" : {
            "expression"       : "attribute_not_exists(id) OR version = :expectedVersion",
            "expressionValues" : {
                ":expectedVersion" : $util.dynamodb.toDynamoDBJson($context.arguments.expectedVersion)
            }
        }
    #end
}
```
Remarque : l'argument expectedVersion est un argument facultatif. Si l'appelant définit un expectedVersion argument dans la demande, le modèle ajoute une condition qui permet à la DeleteItem demande de réussir uniquement si l'élément est déjà supprimé ou si l'versionattribut de la publication dans 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'versionélément ou qu'il existe ou non dans DynamoDB.
Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Remarque : même si vous supprimez un élément, vous pouvez renvoyer l'élément qui a été supprimé, s'il n'était pas déjà supprimé.
Choisissez Save (Enregistrer).

Pour plus d'informations sur le mappage des DeleteItem demandes, consultez la documentation de DeleteItemréférence.

Appelez le 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 DynamoDBDeleteItem. Vous pouvez désormais exécuter une mutation pour supprimer quelque chose dans la table.

Choisissez l'onglet Requêtes.
Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait la valeur que vous avez notée précédemment.
```
mutation deletePost {
  deletePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Choisissez Exécuter une requête (le bouton de lecture orange).

La publication est supprimée de DynamoDB. Notez que cela AWS AppSync renvoie la valeur de l'élément qui a été supprimé de DynamoDB, qui doit apparaître dans le volet des résultats à droite du volet des 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
    }
  }
}

La valeur est renvoyée seulement si cet appel à deletePost est celui qui l'a réellement supprimée de DynamoDB.

Choisissez Exécuter une requête à nouveau.
L'appel réussit quand même, mais aucune valeur n'est renvoyée.
```
{
  "data": {
    "deletePost": null
  }
}
```

Maintenant, essayons de supprimer une publication, mais cette fois en spécifiant expectedValue. Tout d'abord, vous devez créer une nouvelle publication, car vous venez de supprimer celle que vous utilisiez jusqu'à présent.

Collez la mutation suivante dans le volet Requêtes.


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
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Les résultats de la publication nouvellement créée doivent apparaître dans le volet des résultats à droite du volet de requête. Notez l'id de l'objet nouvellement créé, car vous en aurez besoin sous peu. 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
    }
  }
}

Maintenant, essayons de supprimer cette publication, mais insérons une valeur incorrecte pour expectedVersion :

Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait 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
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).


{
  "data": {
    "deletePost": null
  },
  "errors": [
    {
      "path": [
        "deletePost"
      ],
      "data": {
        "id": "123",
        "author": "AUTHORNAME",
        "title": "Our second post!",
        "content": "A new post.",
        "url": "https://aws.amazon.com/appsync/",
        "ups": 1,
        "downs": 0,
        "version": 1
      },
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "locations": [
        {
          "line": 2,
          "column": 3
        }
      ],
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
    }
  ]
}

La demande a échoué car l'expression de la condition est fausse : la valeur version de la publication dans 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
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Cette fois, la demande aboutit et la valeur supprimée de 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
    }
  }
}

Choisissez Exécuter une requête à nouveau.
L'appel réussit toujours, mais cette fois aucune valeur n'est renvoyée car la publication a déjà été supprimée dans DynamoDB.


{
  "data": {
    "deletePost": null
  }
}

Configuration du allPost résolveur (DynamoDB Scan)

Jusqu'à présent, cela n'APIest 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.

Choisissez l'onglet Schéma.

Dans le volet Schéma, modifiez le type Query pour ajouter une nouvelle requête allPost :


type Query {
    allPost(count: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

Ajouter un nouveau type PaginationPosts :


type PaginatedPosts {
    posts: [Post!]!
    nextToken: String
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le allPostchamp nouvellement créé dans le type de requête, puis choisissez Joindre.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.
Collez ce qui suit dans la section Configurer le modèle de mappage de demande :
```
{
    "version" : "2017-02-28",
    "operation" : "Scan"
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": $util.toJson($context.arguments.nextToken)
    #end
}
```
Ce résolveur possède deux arguments facultatifs : count, qui spécifie le nombre maximal d'éléments à renvoyer dans un seul appel, et nextToken, qui peut être utilisé pour récupérer l'ensemble de résultats suivant (vous indiquerez ultérieurement d'où provient la valeur de nextToken).
Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Remarque : ce modèle de mappage de réponse est différent de tous les autres jusqu'à présent. Le résultat de la requête allPost est un PaginatedPosts, qui contient une liste de publications et un jeton de pagination. La forme de cet objet est différente de celle renvoyée par le résolveur AWS AppSync DynamoDB : la liste des publications est appelée items dans les résultats du résolveur AWS AppSync DynamoDB, mais elle est appelée. posts PaginatedPosts
Choisissez Save (Enregistrer).

Pour en savoir plus sur le mappage des demandes Scan, consultez la documentation de référence Scan.

Appelez le API pour scanner tous les messages

Maintenant que le résolveur est configuré, AWS AppSync il sait comment traduire une allPost requête entrante en une opération DynamoDBScan. 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à.

Choisissez l'onglet Requêtes.

Collez la mutation suivante dans le volet Requêtes.


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 }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Maintenant, analysons la table, en renvoyant cinq résultats à la fois.

Collez la requête suivante dans le volet Requêtes :


query allPost {
  allPost(count: 5) {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Les cinq premières publications doivent apparaître dans le volet des résultats à droite du volet de requête. 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": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRkJEdXdUK09hcnovRGhNTGxLTGdMUEFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF6ajFodkhKU1paT1pncTRaUUNBUkNBZ2dHWnJiR1dQWGxkMDB1N0xEdGY4Z2JsbktzRjRua1VCcks3TFJLcjZBTFRMeGFwVGJZMDRqOTdKVFQyYVRwSzdzbVdtNlhWWFVCTnFIOThZTzBWZHVkdDI2RlkxMHRqMDJ2QTlyNWJTUWpTbWh6NE5UclhUMG9KZWJSQ2JJbXBlaDRSVlg0Tis0WTVCN1IwNmJQWWQzOVhsbTlUTjBkZkFYMVErVCthaXZoNE5jMk50RitxVmU3SlJ5WmpzMEFkSGduM3FWd2VrOW5oeFVVd3JlK1loUks5QkRzemdiMDlmZmFPVXpzaFZ4cVJRbC93RURlOTcrRmVJdXZNby9NZ1F6dUdNbFRyalpNR3FuYzZBRnhwa0VlZTFtR0FwVDFISElUZlluakptYklmMGUzUmcxbVlnVHVSbDh4S0trNmR0QVoraEhLVDhuNUI3VnF4bHRtSnlNUXBrZGl6KzkyL3VzNDl4OWhrMnVxSW01ZFFwMjRLNnF0dm9ZK1BpdERuQTc5djhzb0grVytYT3VuQ2NVVDY4TVZ1Wk5KYkRuSEFSSEVlaTlVNVBTelU5RGZ6d2pPdmhqWDNJMWhwdWUrWi83MDVHVjlPQUxSTGlwZWZPeTFOZFhwZTdHRDZnQW00bUJUK2c1eC9Ec3ZDbWVnSDFDVXRTdHVuU1ZFa2JpZytQRC9oMUwyRTNqSHhVQldaa28yU256WUc0cG0vV1RSWkFVZHZuQT09In0="
    }
  }
}

Vous avez cinq résultats et un nextToken que vous pouvez utiliser pour obtenir l'ensemble de résultats suivant.

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(
    count: 5
    nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0="
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Les quatre publications restantes doivent apparaître dans le volet des résultats à droite du volet de requête. Il n'y a pas d'élément nextToken dans cet ensemble de résultats, car vous avez parcouru les neuf publications, et il n'en reste aucune. 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 du résolveur d' allPostsByauteur (requête DynamoDB)

En plus de rechercher dans DynamoDB toutes les publications, vous pouvez également interroger DynamoDB pour récupérer les publications créées par un auteur spécifique. La table 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 DynamoDB pour récupérer toutes les Query publications créées par un auteur spécifique.

Choisissez l'onglet Schéma.
Dans le volet Schéma, modifiez le type Query pour ajouter une nouvelle requête allPostsByAuthor :
```
type Query {
    allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
    allPost(count: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}
```
Remarque : ceci utilise le même type PaginatedPosts que nous avons utilisé avec la requête allPost.
Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le champ allPostsByAuteur nouvellement créé dans le type de requête, puis choisissez Joindre.
Dans le menu Action, choisissez Update runtime, puis Unit Resolver (VTLuniquement).
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "Query",
    "index" : "author-index",
    "query" : {
      "expression": "author = :author",
        "expressionValues" : {
          ":author" : $util.dynamodb.toDynamoDBJson($context.arguments.author)
        }
    }
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": "${context.arguments.nextToken}"
    #end
}

Comme le résolveur allPost, ce résolveur possède deux arguments facultatifs : count, qui spécifie le nombre maximal d'éléments à renvoyer dans un seul appel et nextToken, qui peut être utilisé pour récupérer l'ensemble de résultats suivant (la valeur de nextToken peut être obtenue à partir d'un appel précédent).

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Remarque : il s'agit du même modèle de mappage de réponse que vous avez utilisé dans le résolveur allPost.
Choisissez Save (Enregistrer).

Pour en savoir plus sur le mappage des demandes Query, consultez la documentation de référence Requête.

Appelez le API pour rechercher tous les articles d'un auteur

Maintenant que le résolveur est 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, toutefois, remplissez la table avec d'autres publications car, à ce stade, chaque publication est du même auteur.

Choisissez l'onglet Requêtes.

Collez la mutation suivante dans le volet Requêtes.


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 }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Maintenant, interrogez la table et renvoyez toutes les publications créées par Nadia.

Collez la requête suivante dans le volet Requêtes :


query allPostsByAuthor {
  allPostsByAuthor(author: "Nadia") {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Toutes les publications créées par Nadia doivent apparaître dans le volet des résultats à droite du volet de requête. 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
    }
  }
}

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.

Collez la requête suivante dans le volet Requêtes :


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    count: 5
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Toutes les publications créées par AUTHORNAME doivent apparaître dans le volet des résultats à droite du volet de requête. 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": "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
    }
  }
}

Mettez à jour l'argument nextToken avec la valeur renvoyée par la requête précédente :


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    count: 5
    nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Les publications créées par AUTHORNAME doivent apparaître dans le volet des résultats à droite du volet de requête. 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
    }
  }
}

Utilisation des ensembles

Jusqu'ici, le type Post a été un objet clé/valeur plat. Vous pouvez également modéliser des objets complexes avec le résolveur AWS AppSyncDynamo de base de données, tels que des ensembles, des listes et des cartes.

Mettons à jour notre type Post pour inclure des balises. Une publication peut comporter 0 balises ou plus, 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.

Choisissez l'onglet Schéma.

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!]
}

Dans le volet Schéma, modifiez le type Query pour ajouter une nouvelle requête allPostsByTag :


type Query {
  allPostsByTag(tag: String!, count: Int, nextToken: String): PaginatedPosts!
  allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
  allPost(count: Int, nextToken: String): PaginatedPosts!
  getPost(id: ID): Post
}

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!
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le champ allPostsByTag nouvellement créé dans le type de requête, puis choisissez Joindre.
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "filter": {
      "expression": "contains (tags, :tag)",
        "expressionValues": {
          ":tag": $util.dynamodb.toDynamoDBJson($context.arguments.tag)
        }
    }
    #if( ${context.arguments.count} )
        ,"limit": $util.toJson($context.arguments.count)
    #end
    #if( ${context.arguments.nextToken} )
        ,"nextToken": $util.toJson($context.arguments.nextToken)
    #end
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :


{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le addTagchamp nouvellement créé sur le type de mutation, puis choisissez Attacher.
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "ADD tags :tags, version :plusOne",
        "expressionValues" : {
            ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
            ":plusOne" : { "N" : 1 }
        }
    }
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le removeTagchamp nouvellement créé sur le type de mutation, puis choisissez Attacher.
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
    },
    "update" : {
        "expression" : "DELETE tags :tags ADD version :plusOne",
        "expressionValues" : {
            ":tags" : { "SS": [ $util.toJson($context.arguments.tag) ] },
            ":plusOne" : { "N" : 1 }
        }
    }
}

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).

Appelez le API pour travailler avec les tags

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.

Choisissez l'onglet Requêtes.

Collez la requête suivante dans le volet Requêtes :


query allPostsByAuthor {
  allPostsByAuthor(
    author: "Nadia"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Toutes les publications de Nadia doivent apparaître dans le volet des résultats à droite du volet de requête. 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
    }
  }
}

Utilisons celui avec le titre "The cutest dog in the world". Notez son id car vous l'utiliserez ultérieurement.

Essayons maintenant d'ajouter une balise dog.

Collez la mutation suivante dans le volet Requêtes. 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
  }
}
```
Choisissez Exécuter une requête (le bouton de lecture orange).

La publication est mise à jour avec la nouvelle balise.


{
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

Vous pouvez ajouter encore d'autres balises :

Mettez à jour la mutation pour modifier l'argument tag en spécifiant puppy.


mutation addTag {
  addTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

La publication est mise à jour avec la nouvelle balise.


{
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog",
        "puppy"
      ]
    }
  }
}

Vous pouvez également supprimer des balises :

Collez la mutation suivante dans le volet Requêtes. Vous devrez également mettre à jour l'argument id pour qu'il ait la valeur que vous avez notée précédemment.
```
mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```
Choisissez Exécuter une requête (le bouton de lecture orange).

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"
      ]
    }
  }
}

Vous pouvez également rechercher toutes les publications qui ont une balise :

Collez la requête suivante dans le volet Requêtes :


query allPostsByTag {
  allPostsByTag(tag: "dog") {
    posts {
      id
      title
      tags
    }
    nextToken
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

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
    }
  }
}

Utilisation de listes et de cartes

Outre les ensembles DynamoDB, vous pouvez également utiliser des listes et des cartes DynamoDB pour modéliser des données complexes dans un seul objet.

Ajoutons la possibilité d'ajouter des commentaires aux publications. Cela sera modélisé sous la forme d'une liste d'objets cartographiques sur l'Postobjet dans DynamoDB.

Remarque : dans une application réelle, vous devez modéliser les commentaires dans leur propre table. Dans le cadre de ce didacticiel, vous devez simplement les ajouter dans la table Post.

Choisissez l'onglet Schéma.

Dans le volet Schéma, ajoutez un nouveau type Comment :


type Comment {
    author: String!
    comment: String!
}

Dans le volet Schéma, modifiez le type Post pour ajouter un nouveau champ comments :


type Post {
  id: ID!
  author: String
  title: String
  content: String
  url: String
  ups: Int!
  downs: Int!
  version: Int!
  tags: [String!]
  comments: [Comment!]
}

Dans le volet Schéma, modifiez le type Mutation pour ajouter une nouvelle mutation addComment :


type Mutation {
  addComment(id: ID!, author: String!, comment: String!): Post
  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!
}

Choisissez Save (Enregistrer).
Dans le volet Types de données sur la droite, recherchez le addCommentchamp nouvellement créé sur le type de mutation, puis choisissez Attacher.
Dans Nom de la source de données, choisissez PostDynamoDBTable.

Collez ce qui suit dans la section Configurer le modèle de mappage de demande :


{
  "version" : "2017-02-28",
  "operation" : "UpdateItem",
  "key" : {
    "id" : $util.dynamodb.toDynamoDBJson($context.arguments.id)
  },
  "update" : {
    "expression" : "SET comments = list_append(if_not_exists(comments, :emptyList), :newComment) ADD version :plusOne",
    "expressionValues" : {
      ":emptyList": { "L" : [] },
      ":newComment" : { "L" : [
        { "M": {
          "author": $util.dynamodb.toDynamoDBJson($context.arguments.author),
          "comment": $util.dynamodb.toDynamoDBJson($context.arguments.comment)
          }
        }
      ] },
      ":plusOne" : $util.dynamodb.toDynamoDBJson(1)
    }
  }
}

Cette expression de mise à jour ajoute une liste contenant notre nouveau commentaire à la liste comments existante. Si la liste n'existe pas encore, elle sera créée.

Collez ce qui suit dans la section Configurer le modèle de mappage de réponse :
```
$utils.toJson($context.result)
```
Choisissez Save (Enregistrer).

Appelez le API pour ajouter un commentaire

Maintenant que vous avez configuré les résolveurs, vous savez comment AWS AppSync traduire les addComment demandes entrantes en opérations DynamoDBUpdateItem.

Essayons cela en ajoutant un commentaire à la même publication à laquelle vous avez ajouté les balises.

Choisissez l'onglet Requêtes.

Collez la requête suivante dans le volet Requêtes :


mutation addComment {
  addComment(
    id:10
    author: "Steve"
    comment: "Such a cute dog."
  ) {
    id
    comments {
      author
      comment
    }
  }
}

Choisissez Exécuter une requête (le bouton de lecture orange).

Toutes les publications de Nadia doivent apparaître dans le volet des résultats à droite du volet de requête. Il doit ressembler à l'exemple ci-dessous.


{
  "data": {
    "addComment": {
      "id": "10",
      "comments": [
        {
          "author": "Steve",
          "comment": "Such a cute dog."
        }
      ]
    }
  }
}

Si vous exécutez la demande plusieurs fois, plusieurs commentaires seront ajoutés à la liste.

Conclusion

Dans ce didacticiel, vous avez créé un outil API qui nous permet de manipuler des objets Post dans DynamoDB à l'aide de AWS AppSync GraphQL. Pour plus d'informations, consultez la Référence du modèle de mappage des résolveurs.

Pour nettoyer, vous pouvez supprimer le AppSync GraphQL API de la console.

Pour supprimer la table DynamoDB et IAM le rôle que vous avez créés pour ce didacticiel, vous pouvez exécuter les opérations suivantes pour supprimer la pile, ou accéder à AWSAppSyncTutorialForAmazonDynamoDB la console pour supprimer AWS CloudFormation la pile :


aws cloudformation delete-stack \
    --stack-name AWSAppSyncTutorialForAmazonDynamoDB

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

VTLdidacticiels sur le résolveur

Utiliser des AWS Lambda résolveurs