Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Creazione di una semplice applicazione post utilizzando i resolver DynamoDB
**Nota**
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)
Questo tutorial mostra come importare tabelle Amazon DynamoDB personalizzate e collegarle AWS AppSync a un'API GraphQL.
Puoi consentire il AWS AppSync provisioning delle risorse DynamoDB per tuo conto. In alternativa, se preferisci, puoi connettere le tabelle esistenti a uno schema GraphQL creando un'origine dati e un resolver. In entrambi i casi, potrai leggere e scrivere nel database DynamoDB tramite istruzioni GraphQL e sottoscrivere dati in tempo reale.
Dovrai eseguire operazioni specifiche perché le istruzioni GraphQL possano essere tradotte in operazioni di DynamoDB e perché le risposte possano essere ritradotte in GraphQL. Questo tutorial descrive il processo di configurazione attraverso diversi scenari e modelli di accesso ai dati reali.
## Configurazione delle tabelle DynamoDB
Per iniziare questo tutorial, devi prima seguire i passaggi seguenti per fornire AWS le risorse.
1. Esegui il provisioning AWS delle risorse utilizzando il seguente AWS CloudFormation modello nella 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
```
In alternativa, puoi avviare il seguente CloudFormation stack nella regione US-West 2 (Oregon) del tuo account. AWS
[https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml](https://console.aws.amazon.com/cloudformation/home?region=us-west-2#/stacks/new?templateURL=https://s3.us-west-2.amazonaws.com/awsappsync/resources/dynamodb/AmazonDynamoDBCFTemplate.yaml)
Ciò crea quanto segue:
+ Una tabella DynamoDB `AppSyncTutorial-Post` chiamata che conterrà i dati. `Post`
+ Un ruolo IAM e una policy gestita da IAM associata AWS AppSync per consentire l'interazione con la `Post` tabella.
1. Per ulteriori informazioni sullo stack e sulle risorse create, esegui il comando dell'interfaccia a riga di comando seguente:
```
aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```
1. Per eliminare le risorse in un secondo momento, puoi eseguire quanto segue:
```
aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```
## Creazione dell'API GraphQL
Per creare l'API GraphQL in: AWS AppSync
1. Accedi a Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/).
1. Nella **APIs dashboard**, scegli **Crea API**.
1. Nella finestra **Personalizza la tua API o importa da Amazon DynamoDB**, **scegli** Crea da zero.
1. Scegli **Start** a destra della stessa finestra.
1. Nel campo **Nome API**, imposta il nome dell'API su`AWSAppSyncTutorial`.
1. Scegli **Create** (Crea).
La AWS AppSync console crea una nuova API GraphQL utilizzando la modalità di autenticazione della chiave API. Puoi usare la console per configurare ulteriormente l'API GraphQL ed eseguire query sull'API per le parti restanti di questo tutorial.
## Definizione di una post API di base
Ora che hai creato un'API AWS AppSync GraphQL, puoi configurare uno schema di base che consente la creazione, il recupero e l'eliminazione di base dei dati post.
1. [Accedi a Console di gestione AWS e apri la console. AppSync ](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli l'API che hai appena creato.
1. Nella **barra laterale**, scegli **Schema**.
1. Nel riquadro **Schema**, sostituisci il contenuto con il seguente codice:
```
schema {
query: Query
mutation: Mutation
}
type Query {
getPost(id: ID): Post
}
type Mutation {
addPost(
id: ID!
author: String!
title: String!
content: String!
url: String!
): Post!
}
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
}
```
1. Scegli **Save** (Salva).
Questo schema definisce un tipo `Post` e le operazioni per aggiungere e ottenere oggetti `Post`.
## Configurazione dell'origine dati per le tabelle DynamoDB
Successivamente, collega le query e le mutazioni definite nello schema alla tabella DynamoDB`AppSyncTutorial-Post`.
Innanzitutto, è AWS AppSync necessario conoscere le proprie tabelle. A questo scopo, devi configurare un'origine dati in AWS AppSync:
1. Accedi a Console di gestione AWS e apri la [AppSync console](https://console.aws.amazon.com/appsync/).
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. Nella **barra laterale**, scegli **Data** Sources.
1. Seleziona **Create data source (Crea origine dati)**.
1. Per il **nome dell'origine dati**, inserisci. `PostDynamoDBTable`
1. Per il **tipo di origine dati**, scegli la tabella **Amazon DynamoDB**.
1. **Per **Regione**, scegli US-WEST-2.**
1. Per **Nome tabella**, scegli la tabella **AppSyncTutorial-Post** DynamoDB.
1. Crea un nuovo ruolo IAM (consigliato) o scegli un ruolo esistente con l'`lambda:invokeFunction`autorizzazione IAM. I ruoli esistenti richiedono una policy di fiducia, come spiegato nella sezione [Allegare una fonte di dati](attaching-a-data-source.md).
Di seguito è riportato un esempio di policy IAM che dispone delle autorizzazioni necessarie per eseguire operazioni sulla risorsa:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:function:myFunction",
"arn:aws:lambda:us-east-1:111122223333:function:myFunction:*"
]
}
]
}
```
------
1. Scegli **Create** (Crea).
## Configurazione del resolver AddPost (DynamoDB) PutItem
**Dopo aver AWS AppSync acquisito conoscenza della tabella DynamoDB, è possibile collegarla a singole query e mutazioni definendo i Resolver.** Il primo resolver creato è il `addPost` resolver, che consente di creare un post nella tabella DynamoDB. `AppSyncTutorial-Post`
Un resolver include i componenti seguenti:
+ Posizione nello schema GraphQL per collegare il resolver. In questo caso, stai configurando un resolver nel campo `addPost` nel tipo `Mutation`. Questo resolver verrà richiamato quando il chiamante chiama `mutation { addPost(...){...} }`.
+ Origine dati da usare per il resolver. In questo caso, userai l'origine dati `PostDynamoDBTable` che hai definito in precedenza, per poter aggiungere voci nella tabella DynamoDB `AppSyncTutorial-Post`.
+ Modello di mappatura della richiesta. Lo scopo del modello di mappatura delle richieste è prendere la richiesta in arrivo dal chiamante e tradurla in istruzioni da eseguire con AWS AppSync DynamoDB.
+ Modello di mappatura della risposta. Lo scopo del modello di mappatura della risposta è ritradurre la risposta proveniente da DynamoDB nel risultato previsto da GraphQL. Questo è utile se la forma dei dati in DynamoDB è diversa rispetto al tipo `Post` in GraphQL, ma in questo caso hanno la stessa forma e di conseguenza puoi semplicemente passare i dati.
Per configurare il resolver:
1. [Accedi a e apri la console. Console di gestione AWS AppSync ](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. Nella **barra laterale**, scegli **Data** Sources.
1. Seleziona **Create data source (Crea origine dati)**.
1. Per il **nome dell'origine dati**, inserisci. `PostDynamoDBTable`
1. Per il **tipo di origine dati**, scegli la tabella **Amazon DynamoDB**.
1. **Per **Regione**, scegli US-WEST-2.**
1. Per **Nome tabella**, scegli la tabella **AppSyncTutorial-Post** DynamoDB.
1. Crea un nuovo ruolo IAM (consigliato) o scegli un ruolo esistente con l'`lambda:invokeFunction`autorizzazione IAM. I ruoli esistenti richiedono una policy di fiducia, come spiegato nella sezione [Allegare una fonte di dati](attaching-a-data-source.md).
Di seguito è riportato un esempio di policy IAM che dispone delle autorizzazioni necessarie per eseguire operazioni sulla risorsa:
------
#### [ JSON ]
****
```
{
"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:*"
]
}
]
}
```
------
1. Scegli **Create** (Crea).
1. Scegli la scheda **Schema**.
1. Nel riquadro **Data types (Tipi di dati** a destra, individua il campo **addPost** sul tipo **Mutation (Mutazione)**, quindi scegli **Attach (Collega)**.
1. Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (solo VTL**).
1. Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
1. Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
```
**Nota:** un *tipo* è specificato in tutte le chiavi e in tutti i valori di attributo. Ad esempio, puoi impostare il campo `author` su `{ "S" : "${context.arguments.author}" }`. La `S` parte indica a AWS AppSync e DynamoDB che il valore sarà un valore stringa. Il valore effettivo viene popolato dall'argomento `author`. Analogamente, il campo `version` è un campo numerico, perché usa `N` per il tipo. Infine, stai anche inizializzando i campi `ups`, `downs` e `version`.
Per questo tutorial avete specificato che il `ID!` tipo GraphQL, che indicizza il nuovo elemento inserito in DynamoDB, fa parte degli argomenti del client. AWS AppSync viene fornito con un'utilità per la generazione automatica di ID chiamata `$utils.autoId()` che avresti potuto utilizzare anche sotto forma di. `"id" : { "S" : "${$utils.autoId()}" }` Puoi quindi lasciare semplicemente `id: ID!` fuori dalla definizione dello schema `addPost()` e questo verrà inserito automaticamente. Non utilizzerai questa tecnica per questo tutorial, ma dovresti considerarla una buona pratica quando scrivi su tabelle DynamoDB.
Per ulteriori informazioni sui modelli di mappatura, consulta la documentazione di riferimento [Panoramica sui modelli di mappatura dei resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview). Per ulteriori informazioni sulla mappatura delle GetItem richieste, consulta la [GetItem](aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.md)documentazione di riferimento. Per ulteriori informazioni sui tipi, consulta la documentazione di riferimento [Sistema di tipi (mappatura della richiesta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md).
1. Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
**Nota**: poiché la forma dei dati nella tabella `AppSyncTutorial-Post` corrisponde esattamente alla forma del tipo `Post` in GraphQL, il modello di mappatura della risposta si limita a passare i risultati direttamente. Inoltre, tutti gli esempi mostrati in questo tutorial usano lo stesso modello di mappatura della risposta e di conseguenza devi creare solo un file.
1. Scegli **Save** (Salva).
### Chiamata dell'API per aggiungere un post
Ora che il resolver è configurato, AWS AppSync puoi tradurre una `addPost` mutazione in entrata in un'operazione DynamoDB. PutItem Puoi ora eseguire una mutazione per inserire contenuto nella tabella.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**.
```
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
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ I risultati del nuovo post creato verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
Ecco che cosa è successo:
+ AWS AppSync `addPost`ha ricevuto una richiesta di mutazione.
+ AWS AppSync ha preso la richiesta e il modello di mappatura della richiesta e ha generato un documento di mappatura della richiesta. L'aspetto sarà simile al seguente:
```
{
"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 ha utilizzato il documento di mappatura della richiesta per generare ed eseguire una richiesta DynamoDB`PutItem`.
+ AWS AppSync ha preso i risultati della `PutItem` richiesta e li ha riconvertiti in tipi 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
}
```
+ Ha passato il documento di mappatura della risposta, che è stato passato invariato.
+ Ha restituito il nuovo oggetto creato nella risposta GraphQL.
## Configurazione del GetPost Resolver (DynamoDB) GetItem
Ora che sei in grado di aggiungere dati alla tabella `AppSyncTutorial-Post` DynamoDB, devi configurare `getPost` la query in modo che possa recuperare i dati dalla tabella. `AppSyncTutorial-Post` A questo scopo, devi configurare un altro resolver.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo **getPost** sul tipo **Query**, quindi scegliere **Attach (Collega)**.
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver** (solo VTL).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
}
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
### Chiamata dell'API per ottenere un post
Ora il resolver è stato configurato, AWS AppSync sa come tradurre una `getPost` query in entrata in un'operazione DynamoDB. `GetItem` Puoi ora eseguire una query per recuperare il post creato prima.
+ Seleziona la scheda **Queries (Query)**.
+ Nel riquadro **Queries (Query)** incollare quanto segue:
```
query getPost {
getPost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post recuperato da DynamoDB dovrebbe apparire nel riquadro dei risultati a destra del riquadro delle query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
Ecco che cosa è successo:
+ AWS AppSync ha ricevuto una `getPost` richiesta di interrogazione.
+ AWS AppSync ha preso la richiesta e il modello di mappatura della richiesta e ha generato un documento di mappatura della richiesta. L'aspetto sarà simile al seguente:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : { "S" : "123" }
}
}
```
+ AWS AppSync ha utilizzato il documento di mappatura della richiesta per generare ed eseguire una richiesta DynamoDB GetItem .
+ AWS AppSync ha preso i risultati della `GetItem` richiesta e li ha riconvertiti in tipi 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
}
```
+ Ha passato il documento di mappatura della risposta, che è stato passato invariato.
+ Ha restituito l'oggetto recuperato nella risposta.
In alternativa, prendiamo il seguente esempio:
```
query getPost {
getPost(id:123) {
id
author
title
}
}
```
Se la tua `getPost` query richiede solo il`id`, e `author``title`, puoi modificare il modello di mappatura della richiesta per utilizzare le espressioni di proiezione per specificare solo gli attributi che desideri dalla tabella DynamoDB per evitare trasferimenti di dati non necessari da DynamoDB a. AWS AppSync Ad esempio, il modello di mappatura della richiesta può essere simile allo snippet riportato di seguito:
```
{
"version" : "2017-02-28",
"operation" : "GetItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"projection" : {
"expression" : "#author, id, title",
"expressionNames" : { "#author" : "author"}
}
}
```
## Creare una mutazione UpdatePost (DynamoDB) UpdateItem
Finora è possibile creare e recuperare `Post` oggetti in DynamoDB. Ora configurerai una nuova mutazione per poter aggiornare gli oggetti. Questa operazione verrà eseguita utilizzando l'operazione UpdateItem DynamoDB.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modificare il tipo `Mutation` per aggiungere una nuova mutazione `updatePost` come segue:
```
type Mutation {
updatePost(
id: ID!,
author: String!,
title: String!,
content: String!,
url: String!
): Post
addPost(
author: String!
title: String!
content: String!
url: String!
): Post!
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **updatePost** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (**solo VTL).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
}
```
**Nota:** questo resolver utilizza DynamoDB UpdateItem, che è significativamente diverso dall'operazione. PutItem Invece di scrivere l'intero elemento, stai semplicemente chiedendo a DynamoDB di aggiornare determinati attributi. Questa operazione viene eseguita utilizzando DynamoDB Update Expressions. L'espressione stessa viene specificata nel campo `expression` nella sezione `update`. L'espressione indica di impostare gli attributi `author`, `title`, `content` e url e quindi di incrementare il campo `version`. I valori da usare non appaiono nell'espressione stessa. L'espressione include segnaposto che indicano nomi che iniziano con un carattere di due punti e che vengono quindi definiti nel campo `expressionValues`. Infine, DynamoDB contiene parole riservate che non possono apparire in. `expression` Ad esempio, poiché `url` è una parola riservata, per aggiornare il campo `url` puoi usare i segnaposto dei nomi e definirli nel campo `expressionNames`.
Per ulteriori informazioni sulla mappatura delle `UpdateItem` richieste, consulta la [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md)documentazione di riferimento. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html).
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
### Chiamata dell'API per aggiornare un post
Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una `update` mutazione in entrata in un'operazione DynamoDB. `Update` Possiamo ora eseguire una mutazione per aggiornare l'item scritto in precedenza.
+ Seleziona la scheda **Queries (Query)**.
+ Nel riquadro **Queries (Query)** incollare la seguente mutazione. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
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
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post aggiornato in DynamoDB dovrebbe apparire nel riquadro dei risultati a destra del riquadro delle query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
In questo esempio, i `downs` campi `ups` and non sono stati modificati perché il modello di mappatura delle richieste non AWS AppSync chiedeva a DynamoDB di fare nulla con quei campi. Inoltre, il `version` campo è stato incrementato di 1 perché hai chiesto AWS AppSync a DynamoDB di aggiungere 1 al campo. `version`
## Modifica del Resolver UpdatePost (DynamoDB) UpdateItem
Questo è un buon punto di partenza per la mutazione `updatePost`, ma presenta due problemi principali:
+ Se vogliamo aggiornare un solo campo, dovremo aggiornare tutti i campi.
+ Se due persone stanno modificando l'oggetto, rischiamo di perdere informazioni.
Per risolvere questi problemi, modificherai la mutazione `updatePost` in modo da modificare solo gli argomenti che sono stati specificati nella richiesta e quindi aggiungerai una condizione all'operazione `UpdateItem`.
1. Scegli la scheda **Schema**.
1. Nel riquadro **Schema**, modifica il `updatePost` campo nel `Mutation` tipo per rimuovere i punti esclamativi dagli `url` argomenti`author`, `title``content`, e assicurandoti di lasciare il campo così com'è. `id` In questo modo, questo argomento verrà reso facoltativo. Aggiungere inoltre un nuovo argomento `expectedVersion` obbligatorio.
```
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!
}
```
1. Scegli **Save** (Salva).
1. Nel riquadro **Data types (Tipi di dati)** alla destra, individuare il campo **updatePost** sul tipo **Mutation (Mutazione)**.
1. Scegli **PostDynamoDBTable**di aprire il resolver esistente.
1. Modifica il modello di mappatura della richiesta nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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)
}
}
}
```
1. Scegli **Save** (Salva).
Questo modello è uno degli esempi più complessi. Dimostra la potenza e la flessibilità dei modelli di mappatura. Passa su tutti gli argomenti, ignorando `id` e `expectedVersion`. Se l'argomento è impostato su qualcosa, chiede AWS AppSync a DynamoDB di aggiornare quell'attributo sull'oggetto in DynamoDB. Se l'attributo è impostato su null, chiede AWS AppSync a DynamoDB di rimuovere quell'attributo dall'oggetto post. Se non è stato specificato un argomento, lo ignorerà. Il modello incrementa anche il campo `version`.
È presente anche una nuova sezione `condition`. Un'espressione di condizione consente di indicare AWS AppSync a DynamoDB se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione. In questo caso, si desidera che la `UpdateItem` richiesta abbia esito positivo solo se il `version` campo dell'elemento attualmente in DynamoDB corrisponde esattamente all'argomento. `expectedVersion`
Per ulteriori informazioni sulle espressioni di condizione, consulta la documentazione di riferimento delle [espressioni di condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md).
### Chiamata dell'API per aggiornare un post
Proviamo ad aggiornare l'oggetto `Post` con il nuovo resolver:
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation updatePost {
updatePost(
id:123
title: "An empty story"
content: null
expectedVersion: 2
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post aggiornato in DynamoDB dovrebbe apparire nel riquadro dei risultati a destra del riquadro delle query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
In questa richiesta, hai chiesto a DynamoDB di aggiornare solo `title` il `content` campo AWS AppSync and. Tutti gli altri campi sono stati ignorati (con l'eccezione dell'aumento del campo `version`). Hai impostato l'attributo `title` su un nuovo valore e abbiamo rimosso l'attributo `content` dal post. I campi `author`, `url`, `ups` e `downs` sono stati lasciati invariati.
Prova a eseguire di nuovo la richiesta di mutazione, lasciandola esattamente così com'è. Noterai una risposta simile alla seguente:
```
{
"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 richiesta non riesce perché l'espressione di condizione restituisce false:
+ La prima volta che hai eseguito la richiesta, il valore del `version` campo del post in DynamoDB `2` era corrispondente all'argomento. `expectedVersion` La richiesta è riuscita, il che significa che il `version` campo è stato incrementato in DynamoDB a. `3`
+ La seconda volta che hai eseguito la richiesta, il valore del `version` campo del post in DynamoDB `3` era, che non corrispondeva all'argomento. `expectedVersion`
Questo modello viene in genere chiamato *blocco ottimistico*.
Una caratteristica di un resolver AWS AppSync DynamoDB è che restituisce il valore corrente dell'oggetto post in DynamoDB. Puoi trovare questo valore nel campo `data` nella sezione `errors` della risposta GraphQL. L'applicazione può usare queste informazioni per decidere come procedere. In questo caso, puoi vedere che il `version` campo dell'oggetto in DynamoDB è impostato su, quindi puoi semplicemente aggiornare `expectedVersion` l'argomento `3` `3` a e la richiesta avrà nuovamente esito positivo.
Per ulteriori informazioni sulla gestione degli errori del controllo delle condizioni, consulta la documentazione di riferimento dei modelli di mappatura delle [espressioni di condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md).
## Crea mutazioni UpvotePost e DownvotePost (DynamoDB) UpdateItem
Il tipo `Post` include i campi `ups` e `downs` per consentire di registrare voti positivi e voti negativi, ma finora l'API non ci ha permesso di eseguire alcuna operazione con questi campi. Aggiungiamo ora alcune mutazioni per poter assegnare voti positivi e negativi ai post.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modifica il tipo per aggiungere nuove e mutazioni come segue`Mutation`: `upvotePost` `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!
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **upvotePost** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (solo VTL**).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo `downvotePost` appena creato sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
### Chiamata dell'API per assegnare voti positivi e voti negativi a un post
Ora i nuovi resolver sono stati configurati, AWS AppSync sa come tradurre un'operazione in entrata o una `upvotePost` mutazione `downvote` in DynamoDB. UpdateItem Ora puoi eseguire mutazioni per assegnare voti positivi e voti negativi al post creato prima.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation votePost {
upvotePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post viene aggiornato in DynamoDB e dovrebbe apparire nel riquadro dei risultati a destra del riquadro delle query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
+ Scegli **Execute query (Esegui query)** più volte. I campi `ups` e `version` vengono incrementati di 1 ogni volta che esegui la query.
+ Modifica la query in modo da chiamare la mutazione `downvotePost` come segue:
```
mutation votePost {
downvotePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione). Questa volta, i campi `downs` e `version` vengono incrementati di 1 ogni volta che esegui la query.
```
{
"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
}
}
}
```
## Configurazione del DeletePost Resolver (DynamoDB) DeleteItem
La prossima mutazione che vuoi configurare è quella per l'eliminazione di un post. Questa operazione verrà eseguita utilizzando l'operazione `DeleteItem` DynamoDB.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modificare il tipo `Mutation` per aggiungere una nuova mutazione `deletePost` come segue:
```
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!
}
```
A questo punto il campo `expectedVersion` viene reso opzionale, operazione spiegata in seguito al momento di aggiungere il modello di mappatura della richiesta.
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **delete (elimina)** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (**solo VTL).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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
}
```
**Nota**: l'argomento `expectedVersion` è un argomento facoltativo. Se il chiamante imposta un `expectedVersion` argomento nella richiesta, il modello aggiunge una condizione che consente l'esito positivo della `DeleteItem` richiesta solo se l'elemento è già stato eliminato o se l'`version`attributo del post in DynamoDB corrisponde esattamente a. `expectedVersion` Se non viene inserito, nessuna espressione di condizione viene specificata nella richiesta `DeleteItem`. Ha successo indipendentemente dal valore o dal fatto che l'elemento esista o meno in DynamoDB. `version`
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
**Nota**: anche se stai eliminando un item, puoi restituire l'item che è stato eliminato, se non è già stato eliminato.
+ Scegli **Save** (Salva).
Per ulteriori informazioni sulla mappatura delle `DeleteItem` richieste, consulta la documentazione di riferimento. [DeleteItem](aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.md)
### Chiamata dell'API per eliminare un post
Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una `delete` mutazione in entrata in un'operazione DynamoDB. `DeleteItem` Puoi ora eseguire una mutazione per eliminare qualcosa nella tabella.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation deletePost {
deletePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post viene eliminato da DynamoDB. Nota che AWS AppSync restituisce il valore dell'elemento che è stato eliminato da DynamoDB, che dovrebbe apparire nel riquadro dei risultati a destra del riquadro delle query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
Il valore viene restituito solo se la chiamata a `deletePost` è quella che lo ha effettivamente eliminato da DynamoDB.
+ Scegliere nuovamente **Execute query (Esegui query)**.
+ La chiamata riesce ancora, ma non viene restituito alcun valore.
```
{
"data": {
"deletePost": null
}
}
```
Proviamo ora a eliminare un post, questa volta specificando `expectedValue`. In primo luogo, tuttavia, dovrai creare un nuovo post perché hai appena eliminato quello usato fino a questo punto.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**.
```
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
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ I risultati del nuovo post creato verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. Annotare il valore di `id` del nuovo oggetto creato, perché sarà necessario tra poco. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
Proviamo ora a eliminare il post, ma inserendo un valore errato per `expectedVersion`:
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 9999
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
```
{
"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 richiesta non è riuscita perché l'espressione della condizione risulta falsa: il valore `version` del post in DynamoDB non corrisponde a quello specificato `expectedValue` negli argomenti. Il valore corrente dell'oggetto viene restituito nel campo `data` nella sezione `errors` della risposta GraphQL.
+ Riprova la richiesta, correggendo il valore di `expectedVersion`:
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 1
) {
id
author
title
content
url
ups
downs
version
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Questa volta la richiesta ha esito positivo e viene restituito il valore che è stato eliminato da DynamoDB:
```
{
"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
}
}
}
```
+ Scegliere nuovamente **Execute query (Esegui query)**.
+ La chiamata riesce ancora, ma questa volta non viene restituito alcun valore perché il post è già stato eliminato in DynamoDB.
```
{
"data": {
"deletePost": null
}
}
```
## Configurazione del resolver Up the allPost (scansione di DynamoDB)
Fino a questo punto l'API è utile solo se conosci l'`id` di ogni post che vuoi guardare. Aggiungiamo ora un nuovo resolver che restituisce tutti i post nella tabella.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modificare il tipo `Query` per aggiungere una nuova query `allPost` come segue:
```
type Query {
allPost(count: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
+ Aggiungi un nuovo tipo `PaginationPosts`:
```
type PaginatedPosts {
posts: [Post!]!
nextToken: String
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **allPost** sul tipo **Query**, quindi scegliere **Attach (Collega)**.
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver** (solo VTL).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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
}
```
Questo resolver include due argomenti facoltativi: `count`, che specifica il numero massimo di item da restituire in una singola chiamata, e `nextToken`, che può essere usato per recuperare il set successivo di risultati (vedrai da dove proviene il valore per `nextToken` più tardi).
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
**Nota**: questo modello di mappatura della risposta è diverso da tutti gli altri descritti finora. Il risultato della query `allPost` è un oggetto `PaginatedPosts`, che contiene un elenco dei post e un token di paginazione. La forma di questo oggetto è diversa da quella restituita dal Resolver AWS AppSync DynamoDB: l'elenco dei post viene richiamato `items` nei risultati del Resolver AWS AppSync DynamoDB, ma viene richiamato. `posts` `PaginatedPosts`
+ Scegli **Save** (Salva).
Per ulteriori informazioni sulla mappatura della richiesta `Scan`, consulta la documentazione di riferimento di [Scan](aws-appsync-resolver-mapping-template-reference-dynamodb-scan.md).
### Chiamata dell'API per analizzare tutti i post
Ora il resolver è stato configurato, AWS AppSync sa come tradurre una `allPost` query in entrata in un'operazione DynamoDB. `Scan` Puoi ora analizzare la tabella per recuperare tutti i post.
Prima di provare, devi immettere nella tabella alcuni dati, perché hai eliminato tutti quelli usati finora.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**.
```
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 }
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
Analizziamo ora la tabella, restituendo cinque risultati per volta.
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
query allPost {
allPost(count: 5) {
posts {
id
title
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ I primi cinque post appariranno nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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="
}
}
}
```
Hai ottenuto cinque risultati e una `nextToken` che è possibile utilizzare per ottenere la prossima serie di risultati.
+ Aggiornare la query `allPost` in modo da includere `nextToken` dal set precedente di risultati:
```
query allPost {
allPost(
count: 5
nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0="
) {
posts {
id
author
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ I quattro post rimanenti appariranno nel riquadro dei risultati a destra del riquadro della query. Questo set di risultati non contiene `nextToken`, perché hai analizzato tutti i nove post, senza che ne sia rimasto alcuno. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
## Configurazione dell' allPostsByAuthor Resolver (DynamoDB Query)
Oltre a scansionare DynamoDB per tutti i post, puoi anche interrogare DynamoDB per recuperare i post creati da un autore specifico. La tabella DynamoDB che hai creato in precedenza contiene già `GlobalSecondaryIndex` una `author-index` chiamata che puoi utilizzare con un'operazione DynamoDB per recuperare tutti i `Query` post creati da un autore specifico.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modificare il tipo `Query` per aggiungere una nuova query `allPostsByAuthor` come segue:
```
type Query {
allPostsByAuthor(author: String!, count: Int, nextToken: String): PaginatedPosts!
allPost(count: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
**Nota:** usa lo stesso tipo `PaginatedPosts` utilizzato con la query `allPost`.
+ Scegli **Save** (Salva).
+ **Nel riquadro **Tipi di dati** a destra, individua il campo **allPostsByAutore** appena creato nel campo Tipo di **query**, quindi scegli Allega.**
+ Nel **menu Azione**, scegli **Update runtime**, quindi scegli **Unit Resolver (solo VTL**).
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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
}
```
Come per il resolver `allPost`, questo resolver include due argomenti facoltativi: `count`, che specifica il numero massimo di item da restituire in una singola chiamata, e `nextToken`, che può essere usato per recuperare il set successivo di risultati (il valore per `nextToken` può essere ottenuto da una chiamata precedente).
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
**Nota**: questo è lo stesso modello di mappatura della risposta usato nel resolver `allPost`.
+ Scegli **Save** (Salva).
Per ulteriori informazioni sulla mappatura della richiesta `Query`, consulta la documentazione di riferimento di [Query](aws-appsync-resolver-mapping-template-reference-dynamodb-query.md).
### Chiamata dell'API per eseguire una query per recuperare tutti i post di un autore
Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una `allPostsByAuthor` mutazione in entrata in un'operazione DynamoDB rispetto all'indice. `Query` `author-index` Puoi ora eseguire una query sulla tabella per recuperare tutti i post di un autore specifico.
Prima di continuare, tuttavia, devi immettere altri post nella tabella, perché i post presenti fino a questo punto hanno lo stesso autore.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**.
```
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 }
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
Esegui ora la query sulla tabella, per restituire tutti i post il cui autore è `Nadia`.
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
query allPostsByAuthor {
allPostsByAuthor(author: "Nadia") {
posts {
id
title
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Tutti i post il cui autore è `Nadia` verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you know...?"
}
],
"nextToken": null
}
}
}
```
La paginazione funziona per `Query` esattamente come per `Scan`. Ad esempio, cerchiamo tutti i post di `AUTHORNAME`, restituendone cinque per volta.
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
count: 5
) {
posts {
id
title
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Tutti i post il cui autore è `AUTHORNAME` verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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=="
}
}
}
```
+ Aggiornare l'argomento `nextToken` con il valore restituito dalla query precedente, come segue:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
count: 5
nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnSExqRnVhVUR3ZUhEZ2QzNGJ2QlFuY0FBQUNqekNDQW9zR0NTcUdTSWIzRFFFSEJxQ0NBbnd3Z2dKNEFnRUFNSUlDY1FZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5Qkg4Yk1obW9LVEFTZHM3SUNBUkNBZ2dKQ3dISzZKNlJuN3pyYUVKY1pWNWxhSkNtZW1KZ0F5N1dhZkc2UEdTNHpNQzJycTkwZHFJTFV6Z25wck9Gd3pMS3VOQ2JvUXc3VDI5eCtnVExIbGg4S3BqbzB1YjZHQ3FwcDhvNDVmMG9JbDlmdS9JdjNXcFNNSXFKTXZ1MEVGVWs1VzJQaW5jZGlUaVRtZFdYWlU1bkV2NkgyRFBRQWZYYlNnSmlHSHFLbmJZTUZZM0FTdmRIL0hQaVZBb1RCMk1YZkg0eGJOVTdEbjZtRFNhb2QwbzdHZHJEWDNtODQ1UXBQUVNyUFhHemY0WDkyajhIdlBCSWE4Smcrb0RxbHozUVQ5N2FXUXdYWWU2S0h4emI1ejRITXdEdXEyRDRkYzhoMi9CbW10MzRMelVGUVIyaExSZGRaZ0xkdzF5cHJZdFZwY3dEc1d4UURBTzdOcjV2ZEp4VVR2TVhmODBRSnp1REhXREpTVlJLdDJwWmlpaXhXeGRwRmNod1BzQ3d2aVBqMGwrcWFFWU1jMXNQbENkVkFGem43VXJrSThWbS8wWHlwR2xZb3BSL2FkV0xVekgrbGMrYno1ZEM2SnVLVXdtY1EyRXlZeDZiS0Izbi9YdUViWGdFeU5PMWZTdE1rRlhyWmpvMVpzdlYyUFRjMzMrdEs0ZDhkNkZrdjh5VVR6WHhJRkxIaVNsOUx6VVdtT3BCaWhrTFBCT09jcXkyOHh1UmkzOEM3UFRqMmN6c3RkOUo1VUY0azBJdUdEbVZzM2xjdWg1SEJjYThIeXM2aEpvOG1HbFpMNWN6R2s5bi8vRE1EbDY3RlJraG5QNFNhSDBpZGI5VFEvMERLeFRBTUdhcWpPaEl5ekVqd2ZDQVJleFdlbldyOGlPVkhScDhGM25WZVdvbFRGK002N0xpdi9XNGJXdDk0VEg3b0laUU5lYmZYKzVOKy9Td25Hb1dyMTlWK0pEb2lIRVFLZ1cwMWVuYjZKUXo5Slh2Tm95ZzF3RnJPVmxGc2xwNlRHa1BlN2Rnd2IrWT0ifQ=="
) {
posts {
id
title
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Tutti i post rimanenti il cui autore è `AUTHORNAME` verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"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
}
}
}
```
## Uso di set
Fino a questo punto il `Post` tipo era un oggetto piatto. key/value È inoltre possibile modellare oggetti complessi con il resolver AWS AppSyncDynamo DB, come set, elenchi e mappe.
Aggiorniamo ora il tipo `Post` perché includa tag. Un post può avere 0 o più tag, che vengono memorizzati in DynamoDB come set di stringhe. Dobbiamo anche configurare alcune mutazioni per aggiungere e rimuovere tag e una query per analizzare i post con un tag specifico.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, modificare il tipo `Post` per aggiungere un nuovo campo `tags` come segue:
```
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
tags: [String!]
}
```
+ Nel riquadro **Schema**, modificare il tipo `Query` per aggiungere una nuova query `allPostsByTag` come segue:
```
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
}
```
+ Nel riquadro **Schema**, modifica il `Mutation` tipo per aggiungere nuove `addTag` e `removeTag` mutazioni come segue:
```
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!
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Tipi di dati** a destra, trova il campo **allPostsByTag** appena creato nel tipo di **query**, quindi scegli **Allega**.
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"posts": $utils.toJson($context.result.items)
#if( ${context.result.nextToken} )
,"nextToken": $util.toJson($context.result.nextToken)
#end
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **addTag** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **removeTag** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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 }
}
}
}
```
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
### Chiamata dell'API per usare tag
Ora che hai configurato i resolver, AWS AppSync sa come tradurre le richieste in entrata `addTag` e le richieste `allPostsByTag` in DynamoDB e nelle operazioni. `removeTag` `UpdateItem` `Scan`
Per provare, selezioniamo uno dei post creati prima. Ad esempio, è possibile utilizzare un post redatto dall'utente `Nadia`.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "Nadia"
) {
posts {
id
title
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Tutti i post di Nadia verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you known...?"
}
],
"nextToken": null
}
}
}
```
+ Utilizza quella con il titolo `"The cutest dog in the world"`. Annotiamo il valore di `id`, perché dovrà essere usato più tardi.
Proviamo ora ad aggiungere un tag `dog`.
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation addTag {
addTag(id:10 tag: "dog") {
id
title
tags
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post viene aggiornato con il nuovo tag.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
Possiamo anche aggiungere più tag come segue:
+ Aggiornare la mutazione in modo da modificare l'argomento `tag` in `puppy`.
```
mutation addTag {
addTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post viene aggiornato con il nuovo tag.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
}
}
```
Puoi anche eliminare tag:
+ Incollare la mutazione seguente nel riquadro **Queries (Query)**. Dovremo anche aggiornare l'argomento `id` sul valore che abbiamo annotato in precedenza.
```
mutation removeTag {
removeTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Il post viene aggiornato e il tag `puppy` viene eliminato.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
Puoi anche cercare tutti i post che includono un tag:
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
query allPostsByTag {
allPostsByTag(tag: "dog") {
posts {
id
title
tags
}
nextToken
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Vengono restituiti tutti i post con il tag `dog` come segue:
```
{
"data": {
"allPostsByTag": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
],
"nextToken": null
}
}
}
```
## Uso di elenchi e mappe
Oltre a utilizzare i set DynamoDB, puoi anche utilizzare elenchi e mappe DynamoDB per modellare dati complessi in un singolo oggetto.
Valutiamo ora la possibilità di aggiungere commenti ai post. Questo verrà modellato come un elenco di oggetti della mappa sull'`Post`oggetto in DynamoDB.
**Nota:** in un'applicazione reale, i commenti sarebbero modellati nella propria tabella. Per questo tutorial, aggiungerli nella tabella `Post`.
+ Scegli la scheda **Schema**.
+ Nel riquadro **Schema**, aggiungere un nuovo tipo `Comment` come segue:
```
type Comment {
author: String!
comment: String!
}
```
+ Nel riquadro **Schema**, modificare il tipo `Post` per aggiungere un nuovo campo `comments` come segue:
```
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
tags: [String!]
comments: [Comment!]
}
```
+ Nel riquadro **Schema**, modificare il tipo `Mutation` per aggiungere una nuova mutazione `addComment` come segue:
```
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!
}
```
+ Scegli **Save** (Salva).
+ Nel riquadro **Data types (Tipi di dati)** a destra, individuare il campo appena creato **addComment** sul tipo **Mutation (Mutazione)**, quindi scegliere **Attach (Collega)**.
+ Nel **nome origine dati**, scegliere **PostDynamoDBTable**.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
{
"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)
}
}
}
```
Questa espressione di aggiornamento aggiunge un elenco contenente il nuovo commento all'elenco `comments` esistente. Se l'elenco non esiste già, viene creato.
+ Incollare il codice seguente nella sezione **Configure the request mapping template (Configura il modello di mappatura della richiesta)**:
```
$utils.toJson($context.result)
```
+ Scegli **Save** (Salva).
### Chiamata dell'API per aggiungere un commento
Ora che hai configurato i resolver, AWS AppSync sa come tradurre le richieste `addComment` in arrivo in operazioni DynamoDB. `UpdateItem`
Proviamo ora ad aggiungere un commento allo stesso post cui abbiamo aggiunto i tag.
+ Seleziona la scheda **Queries (Query)**.
+ Incollare la query seguente nel riquadro **Queries (Query)**:
```
mutation addComment {
addComment(
id:10
author: "Steve"
comment: "Such a cute dog."
) {
id
comments {
author
comment
}
}
}
```
+ Scegliere **Execute query (Esegui query)** (il pulsante di riproduzione arancione).
+ Tutti i post di Nadia verranno visualizzati nel riquadro dei risultati a destra del riquadro della query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:
```
{
"data": {
"addComment": {
"id": "10",
"comments": [
{
"author": "Steve",
"comment": "Such a cute dog."
}
]
}
}
}
```
Se esegui la richiesta più volte, all'elenco verranno aggiunti più commenti.
## Conclusioni
In questo tutorial, hai creato un'API che ci consente di manipolare gli oggetti Post in DynamoDB AWS AppSync utilizzando GraphQL. Per altre informazioni, vedere la [Informazioni di riferimento sui modelli di mappatura dei resolver](resolver-mapping-template-reference.md#aws-appsync-resolver-mapping-template-reference).
Per eseguire la pulizia, puoi eliminare l'API AppSync GraphQL dalla console.
Per eliminare la tabella DynamoDB e il ruolo IAM che hai creato per questo tutorial, puoi eseguire quanto segue per eliminare lo stack oppure visitare `AWSAppSyncTutorialForAmazonDynamoDB` la console ed eliminare CloudFormation lo stack:
```
aws cloudformation delete-stack \
--stack-name AWSAppSyncTutorialForAmazonDynamoDB
```