Configurazione delle tabelle DynamoDB Creazione dell'API GraphQL Definizione di un'API post di base Configurazione dell'origine dati per le tabelle DynamoDB Configurazione del resolver AddPost (DynamoDB) PutItem Configurazione del GetPost Resolver (DynamoDB) GetItem Creare una mutazione UpdatePost (DynamoDB) UpdateItem Modifica del Resolver UpdatePost (DynamoDB) UpdateItem Crea mutazioni UpvotePost e DownvotePost (DynamoDB) UpdateItem Configurazione del DeletePost Resolver (DynamoDB) DeleteItem Configurazione del resolver Up the allPost (scansione di DynamoDB)Configurazione dell' allPostsByAuthor Resolver (DynamoDB Query)Uso di set Uso di elenchi e mappe Conclusioni

Tutorial: resolver DynamoDB

Nota

Ora supportiamo principalmente il runtime APPSYNC_JS e la relativa documentazione. Prendi in considerazione l'utilizzo del runtime APPSYNC_JS e delle relative guide qui.

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.

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 AWS CloudFormation stack nella regione US-West 2 (Oregon) del tuo account. AWS

Ciò crea quanto segue:
- Una tabella DynamoDB AppSyncTutorial-Post chiamata che conterrà i dati. Post
- Un ruolo IAM e una policy gestita IAM associata per permettere ad AWS AppSync di interagire con la tabella Post.
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
```

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:

Accedere alla AWS Management Console e aprire la console AppSync .
1. Nella dashboard delle API, scegli Crea API.
Nella finestra Personalizza la tua API o importa da Amazon DynamoDB, scegli Crea da zero.
1. Scegli Start a destra della stessa finestra.
Nel campo Nome API, imposta il nome dell'API suAWSAppSyncTutorial.
Seleziona Create (Crea).

La console AWS AppSync crea una nuova API GraphQL per l'uso della modalità di autenticazione delle chiavi 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 un'API post 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.

Accedere alla AWS Management Console e aprire la console AppSync .
1. Nella dashboard delle API, scegli l'API che hai appena creato.

Nella barra laterale, scegli Schema.

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

Seleziona 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 DynamoDBAppSyncTutorial-Post.

Prima di tutto, AWS AppSync deve essere in grado di riconoscere le tabelle. A questo scopo, devi configurare un'origine dati in AWS AppSync:

Accedere alla AWS Management Console e aprire la console AppSync .
1. Nella dashboard delle API, scegli la tua API GraphQL.
2. Nella barra laterale, scegli Data Sources.
Seleziona Create data source (Crea origine dati).
1. Per il nome della fonte di dati, inserisci. PostDynamoDBTable
2. Per il tipo di origine dati, scegli la tabella Amazon DynamoDB.
3. Per Regione, scegli US-WEST-2.
4. Per Nome tabella, scegli la tabella AppSyncTutorial-Post DynamoDB.
5. Crea un nuovo ruolo IAM (consigliato) o scegli un ruolo esistente con l'lambda:invokeFunctionautorizzazione IAM. I ruoli esistenti richiedono una policy di fiducia, come spiegato nella sezione Allegare una fonte di dati.
  
  Di seguito è riportato un esempio di policy IAM che dispone delle autorizzazioni necessarie per eseguire operazioni sulla risorsa:
```
{ 
     "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:*" 
             ] 
         } 
     ] 
 }
```
Seleziona 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 della richiesta è tradurre la richiesta in ingresso dal chiamante in istruzioni per AWS AppSync da eseguire su 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:

Accedere alla AWS Management Console e aprire la console AppSync .
1. Nella dashboard delle API, scegli la tua API GraphQL.
2. Nella barra laterale, scegli Data Sources.
Seleziona Create data source (Crea origine dati).
1. Per il nome della fonte di dati, inserisci. PostDynamoDBTable
2. Per il tipo di origine dati, scegli la tabella Amazon DynamoDB.
3. Per Regione, scegli US-WEST-2.
4. Per Nome tabella, scegli la tabella AppSyncTutorial-Post DynamoDB.
5. Crea un nuovo ruolo IAM (consigliato) o scegli un ruolo esistente con l'lambda:invokeFunctionautorizzazione IAM. I ruoli esistenti richiedono una policy di fiducia, come spiegato nella sezione Allegare una fonte di dati.
  
  Di seguito è riportato un esempio di policy IAM che dispone delle autorizzazioni necessarie per eseguire operazioni sulla risorsa:
```
{ 
     "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:*" 
             ] 
         } 
     ] 
 }
```
Seleziona Create (Crea).
Scegli la scheda Schema.
Nel riquadro Data types (Tipi di dati a destra, individua il campo addPost sul tipo Mutation (Mutazione), quindi scegli Attach (Collega).
Nel menu Azione, scegli Update runtime, quindi scegli Unit Resolver (solo VTL).
Nel nome dell'origine dati, scegli DbTable. PostDynamo
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 AppSyncviene 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. Per ulteriori informazioni sulla mappatura delle GetItem richieste, consulta la GetItemdocumentazione di riferimento. Per ulteriori informazioni sui tipi, consulta la documentazione di riferimento Sistema di tipi (mappatura della richiesta).
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.
Seleziona 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 addPostha 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 DynamoDBPutItem.

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 dell'origine dati, scegli DbTable. PostDynamo

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)
```
Seleziona 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 ilid, e authortitle, 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!
}

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo
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 UpdateItemdocumentazione di riferimento. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di UpdateExpressions DynamoDB.
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.

Scegli la scheda Schema.

Nel riquadro Schema, modifica il updatePost campo nel Mutation tipo per rimuovere i punti esclamativi dagli url argomentiauthor, titlecontent, 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!
}

Seleziona Salva.
Nel riquadro Data types (Tipi di dati) alla destra, individuare il campo updatePost sul tipo Mutation (Mutazione).
Scegli PostDynamoDbTable per aprire il resolver esistente.

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

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

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.

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

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo

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)
```
Seleziona 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 dell'origine dati, scegli 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)
```
Seleziona 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.

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo
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'versionattributo 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.
Seleziona Salva.

Per ulteriori informazioni sulla mappatura delle DeleteItem richieste, consulta la documentazione di riferimento. DeleteItem

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. AWS AppSync restituisce il valore dell'item che è stato eliminato da DynamoDB, che verrà visualizzato nel riquadro dei risultati a destra del riquadro della 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
}

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo
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 quello restituito dal resolver DynamoDB di AWS AppSync : l'elenco dei post è denominato items nei risultati del resolver DynamoDB di AWS AppSync , ma è denominato posts in PaginatedPosts.
Seleziona Salva.

Per ulteriori informazioni sulla mappatura della richiesta Scan, consulta la documentazione di riferimento di Scan.

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.

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo

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.
Seleziona Salva.

Per ulteriori informazioni sulla mappatura della richiesta Query, consulta la documentazione di riferimento di Query.

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 momento il tipo Post è stato un oggetto chiave/valore semplice. È 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 archiviati 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!
}

Seleziona Salva.
Nel riquadro Tipi di dati a destra, trova il campo allPostsByTag appena creato nel tipo di query, quindi scegli Allega.
Nel nome dell'origine dati, scegli 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
}

Seleziona 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 dell'origine dati, scegli 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)
```
Seleziona 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 dell'origine dati, scegli 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)
```
Seleziona 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'Postoggetto 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!
}

Seleziona 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 dell'origine dati, scegli DbTable. PostDynamo

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)
```
Seleziona 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.

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 AWS CloudFormation lo stack:


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

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Tutorial Resolver (VTL)

Tutorial: resolver Lambda