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

Mode de mise au point

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

Création de votre API GraphQL Définition d'une API de publication de base Configuration de votre table Amazon DynamoDB Configuration d'un résolveur AddPost (Amazon DynamoDB) PutItem Configuration du résolveur GetPost (Amazon DynamoDB) GetItem Création d'une mutation UpdatePost (Amazon DynamoDB) UpdateItem Création de mutations de vote (Amazon DynamoDB UpdateItem)Configuration d'un résolveur DeletePost (Amazon DynamoDB) DeleteItem Configuration d'un résolveur AllPost (Amazon DynamoDB Scan)Configuration d'un résolveur d' allPostsByauteur (requête Amazon DynamoDB)Utiliser des ensembles Conclusion

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

Ouvrez la AppSync console et choisissez Create API.
Sélectionnez Design from scratch et choisissez Next.
Donnez un nom à votre APIPostTutorialAPI, puis choisissez Next. Passez à la page de révision tout en conservant les valeurs par défaut pour les autres options, puis choisissezCreate.

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

Dans votre API, choisissez l'onglet Schéma.

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

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 que nous utiliserons ultérieurement.

Pour créer votre table Amazon DynamoDB

Sur la page Schéma, choisissez Create Resources.
Choisissez Utiliser le type existant, puis choisissez le Post type.
Dans la section Index supplémentaires, choisissez Ajouter un index.
Donnez un nom à l'indexauthor-index.
Réglez le Primary key point sur author et la Sort touche surNone.
Désactivez Générer automatiquement GraphQL. Dans cet exemple, nous allons créer le résolveur nous-mêmes.
Sélectionnez Create (Créer).

Vous avez maintenant une nouvelle source de données appeléePostTable, 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

Dans votre API, choisissez l'onglet Schéma.
Dans le volet Résolveurs, recherchez le addPost champ situé sous le Mutation type, puis choisissez Attacher.
Choisissez votre source de données, puis sélectionnez Créer.

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
}

Choisissez Save (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.

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

Pour exécuter l'opération

Dans votre API, choisissez l'onglet Requêtes.

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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezaddPost. 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é :

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

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

AWS AppSync utilise cette valeur pour générer et exécuter une demande Amazon 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
}

Le gestionnaire de réponses renvoie le résultat immédiatement (return ctx.result).
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

Dans votre API, choisissez l'onglet Schéma.
Dans le volet Resolvers sur la droite, recherchez le getPost champ correspondant au Query type, puis choisissez Attacher.
Choisissez votre source de données, puis sélectionnez Créer.

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

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 DynamoDBGetItem. 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

Dans votre API, choisissez l'onglet Requêtes.
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
  }
}
```
Choisissez Exécuter (le bouton de lecture orange), puis choisissezgetPost. Les résultats de la publication nouvellement créée doivent apparaître dans le volet Résultats à droite du volet Requêtes.

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 duid, et authortitle, 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 selectionSetListsigne 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

Dans votre API, 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,
        expectedVersion: Int!
    ): Post
    
    addPost(
        id: ID
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

Choisissez Sauvegarder schéma.

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;

Enregistrez toutes les modifications que vous avez apportées.

Ce résolveur permet ddb.update de créer une demande Amazon DynamoDBUpdateItem. 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 surnull, 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 duversion. C'est facile à faire avec la fonction d'opérationincrement.

Pour plus d'informations sur les expressions de condition, consultez la documentation sur les expressions de condition.

Pour plus d'informations sur la UpdateItem demande, consultez la UpdateItemdocumentation et celle du module DynamoDB.

Pour plus d'informations sur la façon d'écrire des expressions de mise à jour, consultez la documentation UpdateExpressionsDynamoDB.

Appelez l'API pour mettre à jour une publication

Essayons de mettre à jour l'Postobjet avec le nouveau résolveur.

Pour mettre à jour votre objet

Dans votre API, choisissez l'onglet Requêtes.

Dans le volet Requêtes, ajoutez la mutation suivante. Vous devrez également mettre à jour l'idargument 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
  }
}

Choisissez Exécuter (le bouton de lecture orange), puis choisissezupdatePost.

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'contentavez 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 :

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

Dans votre API, choisissez l'onglet Schéma.

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
}

Choisissez Sauvegarder schéma.

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;

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 DynamoDBUpdateItem. 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

Dans votre API, choisissez l'onglet Requêtes.
Dans le volet Requêtes, ajoutez la mutation suivante. Vous devrez également mettre à jour l'idargument 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
  }
}
```
Choisissez Exécuter (le bouton de lecture orange), puis choisissezvotePost.

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

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.

Modifiez la requête pour l'appeler avec un nom différentDIRECTION.


mutation votePost {
  vote(id:123, direction: DOWN) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Choisissez Exécuter (le bouton de lecture orange), puis choisissezvotePost.

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

Dans votre schéma, choisissez l'onglet Schéma.

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

Cette fois, vous avez rendu le expectedVersion champ facultatif. Ensuite, choisissez Enregistrer le schéma.
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'expectedVersionargument 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'versionattribut 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 DeleteItemdocumentation.

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

Pour exécuter votre mutation

Dans votre API, choisissez l'onglet Requêtes.
Dans le volet Requêtes, ajoutez la mutation suivante. Vous devrez également mettre à jour l'idargument avec 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 (le bouton de lecture orange), puis choisissezdeletePost.

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

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.
L'appel réussit toujours, mais aucune valeur n'est renvoyée :
```
{
  "data": {
    "deletePost": null
  }
}
```
Essayons maintenant de supprimer un message, mais cette fois en spécifiant unexpectedValue. Tout d'abord, vous devez créer une nouvelle publication, car vous venez de supprimer celle sur laquelle vous avez travaillé jusqu'à présent.

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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezaddPost.

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

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'idargument 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
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezdeletePost. 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)"
    }
  ]
}

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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezdeletePost.

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

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

Dans votre API, choisissez l'onglet Schéma.

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
}

Ajouter un nouveau type PaginationPosts :


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

Choisissez Sauvegarder schéma.
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).
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.

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 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à.

Pour ajouter et interroger des données

Dans votre API, choisissez l'onglet Requêtes.

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

Choisissez Exécuter (le bouton de lecture orange).
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
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPost.

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": "<token>"
    }
  }
}

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: "<token>"
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPost.

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

Dans votre API, 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!, 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.
Choisissez Sauvegarder schéma.
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).
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.

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

Dans votre API, choisissez l'onglet Requêtes.

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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezaddPost.
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
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPostsByAuthor. 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
    }
  }
}

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.

Dans le volet Requêtes, ajoutez la requête suivante :


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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPostsByAuthor. 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": "<token>"
    }
  }
}

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: "<token>"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPostsByAuthor. 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 objet clé/valeur 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

Dans votre API, 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!, limit: Int, nextToken: String): PaginatedPosts!
  allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
  allPost(limit: 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 Sauvegarder schéma.

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

Enregistrez toutes les modifications que vous avez apportées à votre résolveur.

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

Enregistrez toutes les modifications apportées à votre résolveur.

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

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

Dans votre API, choisissez l'onglet Requêtes.

Dans le volet Requêtes, ajoutez la requête suivante :


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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPostsByAuthor.

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

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

Choisissez Exécuter (le bouton de lecture orange), puis choisissezaddTag. Le message est mis à jour avec le nouveau tag :


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

Vous pouvez ajouter d'autres tags. Mettez à jour la mutation pour remplacer l'tagargument par puppy :
```
mutation addTag {
  addTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezaddTag. Le message est mis à jour avec le nouveau tag :


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

Vous pouvez également supprimer des balises. Dans le volet Requêtes, ajoutez la mutation suivante. Vous devrez également mettre à jour l'idargument avec la valeur que vous avez notée précédemment :
```
mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```

Choisissez Exécuter (le bouton de lecture orange), puis choisissezremoveTag. 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 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
  }
}

Choisissez Exécuter (le bouton de lecture orange), puis choisissezallPostsByTag. 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.

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

JavaScript didacticiels sur le résolveur

Utiliser des AWS Lambda résolveurs

Rubrique suivante :

Utiliser des AWS Lambda résolveurs

Rubrique précédente :

JavaScript didacticiels sur le résolveur

Avez-vous besoin d’aide ?

Sur cette page

Cette page vous a-t-elle été utile ?

Faire un commentaire

Confidentialité Conditions d'utilisation du site Préférences de cookies

Sélectionner vos préférences de cookies

Personnaliser les préférences de cookies

Essentiels

Performances

Fonctionnels

Publicitaires

Impossible d'enregistrer les préférences concernant les cookies

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

Création de votre API GraphQL

Définition d'une API de publication de base

Configuration de votre table Amazon DynamoDB

Configuration d'un résolveur AddPost (Amazon DynamoDB) PutItem

Note

Appelez l'API pour ajouter une publication

Configuration du résolveur GetPost (Amazon DynamoDB) GetItem

Note

Appelez l'API pour obtenir un message

Création d'une mutation UpdatePost (Amazon DynamoDB) UpdateItem

Appelez l'API pour mettre à jour une publication

Création de mutations de vote (Amazon DynamoDB UpdateItem)

Appelez l'API pour voter pour ou contre une publication

Configuration d'un résolveur DeletePost (Amazon DynamoDB) DeleteItem

Note

Appelez l'API pour supprimer une publication

Configuration d'un résolveur AllPost (Amazon DynamoDB Scan)

Appelez l'API pour scanner tous les posts

Configuration d'un résolveur d' allPostsByauteur (requête Amazon DynamoDB)

Appelez l'API pour interroger tous les articles par auteur

Utiliser des ensembles

Note

Appel de l'API pour utiliser des balises

Conclusion

Rubrique suivante :

Rubrique précédente :

Avez-vous besoin d’aide ?

Sur cette page

Cette page vous a-t-elle été utile ?