DynamoDB-Tabellen einrichten Erstellen Sie Ihre GraphQL-API Definition einer grundlegenden Post-API Konfiguration der Datenquelle für die DynamoDB-Tabellen Den AddPost-Resolver einrichten (DynamoDB) PutItem Einrichtung des GetPost-Resolvers (DynamoDB) GetItem Eine UpdatePost-Mutation erstellen (DynamoDB) UpdateItem Ändern des UpdatePost-Resolvers (DynamoDB) UpdateItem UpvotePost- und DownvotePost-Mutationen erstellen (DynamoDB) UpdateItem Den DeletePost-Resolver einrichten (DynamoDB) DeleteItem Einrichten des allPost-Resolvers (DynamoDB Scan)Den allPostsBy Author Resolver einrichten (DynamoDB Query)Verwenden von Sätzen Verwenden von Listen und Zuordnungen Schlussfolgerung

Tutorial: DynamoDB-Resolver

Anmerkung

Wir unterstützen jetzt hauptsächlich die APPSYNC_JS-Laufzeit und ihre Dokumentation. Bitte erwägen Sie, die APPSYNC_JS-Laufzeit und ihre Anleitungen hier zu verwenden.

Dieses Tutorial zeigt, wie Sie Ihre eigenen Amazon DynamoDB-Tabellen mit einer GraphQL-API verbinden können. AWS AppSync

Sie können DynamoDB-Ressourcen in Ihrem Namen AWS AppSync bereitstellen lassen. Alternativ können Sie auch vorhandene Tabellen mit einem GraphQL-Schema verbinden, indem Sie eine Datenquelle und einen Resolver erstellen. In beiden Fällen können Sie Lese- und Schreibvorgänge in Ihrer DynamoDB-Datenbank über GraphQL-Anweisungen ausführen – und Echtzeit-Daten abonnieren.

Es müssen bestimmte Konfigurationsschritte ausgeführt werden, damit GraphQL-Anweisungen in DynamoDB-Operationen und die Antworten wieder in GraphQL übersetzt werden können. In diesem Tutorial wird der Konfigurationsprozess anhand mehrerer Szenarien und Datenzugriffsmuster aus der Praxis veranschaulicht.

DynamoDB-Tabellen einrichten

Um mit diesem Tutorial zu beginnen, müssen Sie zunächst die folgenden Schritte ausführen, um Ressourcen bereitzustellenAWS.

Stellen Sie AWS Ressourcen mithilfe der folgenden AWS CloudFormation Vorlage in der CLI bereit:
```
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
```
Alternativ können Sie den folgenden AWS CloudFormation Stack in der Region US-West 2 (Oregon) in Ihrem AWS Konto starten.

Dadurch wird Folgendes erstellt:
- Eine DynamoDB-Tabelle namensAppSyncTutorial-Post, die Daten enthalten Post wird.
- Eine IAM-Rolle und die zugehörige, von IAM verwaltete Richtlinie, um die Interaktion mit der Tabelle AWS AppSync zu ermöglichen. Post
Wenn Sie weitere Informationen zum Stack und den erstellten Ressourcen benötigen, führen Sie den folgenden CLI-Befehl aus:
```
aws cloudformation describe-stacks --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```
Wenn Sie die Ressourcen später löschen möchten, führen Sie folgenden Befehl aus:
```
aws cloudformation delete-stack --stack-name AWSAppSyncTutorialForAmazonDynamoDB
```

Erstellen Sie Ihre GraphQL-API

Erstellen Sie die GraphQL-API in AWS AppSync wie folgt:

Melden Sie sich bei der AWS Management Console an und öffnen Sie die AppSync -Konsole.
1. Wählen Sie im APIs-Dashboard die Option Create API aus.
Wählen Sie im Fenster Passen Sie Ihre API an oder importieren Sie aus Amazon DynamoDB die Option Von Grund auf neu erstellen.
1. Wählen Sie rechts neben demselben Fenster Start aus.
Stellen Sie im Feld API-Name den Namen der API auf einAWSAppSyncTutorial.
Wählen Sie Erstellen aus.

Die AWS AppSync -Konsole erstellt eine neue GraphQL-API mit einem API-Schlüssel als Authentifizierungsmodus. Sie können in der Konsole den Rest der GraphQL-API einrichten und im weiteren Verlauf dieses Tutorials abfragen.

Definition einer grundlegenden Post-API

Nachdem Sie eine AWS AppSync GraphQL-API erstellt haben, können Sie ein grundlegendes Schema einrichten, das das grundlegende Erstellen, Abrufen und Löschen von Post-Daten ermöglicht.

Melden Sie sich bei der AWS Management Console an und öffnen Sie die AppSync -Konsole.
1. Wählen Sie im API-Dashboard die API aus, die Sie gerade erstellt haben.

Wählen Sie in der Seitenleiste Schema aus.

Ersetzen Sie im Schemabereich den Inhalt durch den folgenden Code:


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

Wählen Sie Speichern aus.

Dieses Schema definiert einen Post-Typ und Operationen zum Hinzufügen und Abrufen von Post-Objekten.

Konfiguration der Datenquelle für die DynamoDB-Tabellen

Verknüpfen Sie als Nächstes die im Schema definierten Abfragen und Mutationen mit der AppSyncTutorial-Post DynamoDB-Tabelle.

Zunächst muss AWS AppSync wissen, mit welchen Tabellen Sie arbeiten. Hierzu richten Sie eine Datenquelle in AWS AppSync ein:

Melden Sie sich bei der AWS Management Console an und öffnen Sie die AppSync -Konsole.
1. Wählen Sie im API-Dashboard Ihre GraphQL-API aus.
2. Wählen Sie in der Seitenleiste Datenquellen aus.
Klicken Sie auf Create data source.
1. Geben Sie als Namen der Datenquelle in PostDynamoDBTable ein.
2. Wählen Sie als Datenquellentyp Amazon DynamoDB-Tabelle aus.
3. Wählen Sie für Region US-WEST-2 aus.
4. Wählen Sie als Tabellenname die DynamoDB-Tabelle AppSyncTutorial-Post aus.
5. Erstellen Sie eine neue IAM-Rolle (empfohlen) oder wählen Sie eine vorhandene Rolle aus, die über die IAM-Berechtigung verfügt. lambda:invokeFunction Für bestehende Rollen ist eine Vertrauensrichtlinie erforderlich, wie im Abschnitt Eine Datenquelle anhängen beschrieben.
  
  Im Folgenden finden Sie ein Beispiel für eine IAM-Richtlinie, die über die erforderlichen Berechtigungen für die Ausführung von Vorgängen auf der Ressource verfügt:
```
{ 
     "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:*" 
             ] 
         } 
     ] 
 }
```
Wählen Sie Erstellen aus.

Den AddPost-Resolver einrichten (DynamoDB) PutItem

Nachdem AWS AppSync Sie die DynamoDB-Tabelle erkannt haben, können Sie sie mit einzelnen Abfragen und Mutationen verknüpfen, indem Sie Resolver definieren. Der erste Resolver, den Sie erstellen, ist der addPost Resolver, mit dem Sie einen Beitrag in der AppSyncTutorial-Post DynamoDB-Tabelle erstellen können.

Resolver bestehen aus folgenden Komponenten:

Die Stelle im GraphQL-Schema, an der der Resolver angefügt werden soll. In diesem Fall richten Sie einen Resolver im Feld addPost im Typ Mutation ein. Diesen Resolver können Sie mit mutation { addPost(...){...} } aufrufen.
Die Datenquelle für diesen Resolver. In diesem Fall soll die zuvor definierte Datenquelle PostDynamoDBTable verwendet werden, damit Sie Einträge in der DynamoDB-Tabelle AppSyncTutorial-Post hinzufügen können.
Die Zuweisungsvorlage für Anforderungen. Mit der Zuweisungsvorlage für Anforderungen wird eine eingehende Anforderung des Aufrufers in Anweisungen für AWS AppSync übersetzt, die für DynamoDB ausgeführt werden sollen.
Die Zuweisungsvorlage für Antworten. Eine Zuweisungsvorlage für Antworten übersetzt die Antwort aus DynamoDB zurück in eine Eingabe, die GraphQL erwartet. Dies ist nützlich, wenn sich das Format der Daten in DynamoDB vom Post-Typ in GraphQL unterscheidet. In diesem Fall stimmt die Form jedoch überein, daher werden die Daten direkt übergeben.

Richten Sie den Resolver wie folgt ein:

Melden Sie sich bei der AWS Management Console an und öffnen Sie die AppSync -Konsole.
1. Wählen Sie im API-Dashboard Ihre GraphQL-API aus.
2. Wählen Sie in der Seitenleiste Datenquellen aus.
Klicken Sie auf Create data source.
1. Geben Sie als Namen der Datenquelle in PostDynamoDBTable ein.
2. Wählen Sie als Datenquellentyp Amazon DynamoDB-Tabelle aus.
3. Wählen Sie für Region US-WEST-2 aus.
4. Wählen Sie als Tabellenname die DynamoDB-Tabelle AppSyncTutorial-Post aus.
5. Erstellen Sie eine neue IAM-Rolle (empfohlen) oder wählen Sie eine vorhandene Rolle aus, die über die IAM-Berechtigung verfügt. lambda:invokeFunction Für bestehende Rollen ist eine Vertrauensrichtlinie erforderlich, wie im Abschnitt Eine Datenquelle anhängen beschrieben.
  
  Im Folgenden finden Sie ein Beispiel für eine IAM-Richtlinie, die über die erforderlichen Berechtigungen für die Ausführung von Vorgängen auf der Ressource verfügt:
```
{ 
     "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:*" 
             ] 
         } 
     ] 
 }
```
Wählen Sie Erstellen aus.
Wählen Sie die Registerkarte Schema aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das Feld addPost des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.
Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:
```
{
    "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 }
    }
}
```
Hinweis: Für alle Schlüssel und Attributwerte wird ein Typ angegeben. So legen Sie beispielsweise das Feld author auf { "S" : "${context.arguments.author}" } fest. Der S Teil gibt an AWS AppSync und DynamoDB an, dass der Wert ein Zeichenkettenwert sein wird. Der tatsächliche Wert wird aus dem author-Argument eingefügt. Das Feld version ist ein Zahlenfeld, da als Typ N verwendet wird. Schließlich initialisieren Sie auch die Felder ups, downs und version.

Für dieses Tutorial haben Sie angegeben, dass der ID! GraphQL-Typ, der das neue Element, das in DynamoDB eingefügt wird, indexiert, Teil der Client-Argumente ist. AWS AppSyncenthält ein Hilfsprogramm zur automatischen ID-Generierung namens$utils.autoId(), das Sie auch in der Form von hätten verwenden können. "id" : { "S" : "${$utils.autoId()}" } Dann würden Sie id: ID! nicht in der Schemadefinition von addPost() angeben, sondern die ID würde automatisch eingefügt. Sie werden diese Technik in diesem Tutorial nicht verwenden, sollten sie jedoch als bewährte Methode beim Schreiben in DynamoDB-Tabellen betrachten.

Weitere Informationen zu Lambda-Zuweisungsvorlagen finden Sie in der Referenzdokumentation Übersicht über die Resolver-Zuweisungsvorlage. Weitere Informationen zur GetItem Anforderungszuordnung finden Sie in der GetItemReferenzdokumentation. Weitere Informationen zu Typen enthält die Referenzdokumentation Typsystem (Anforderungszuweisung).
Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Hinweis: Da das Format der Daten in der Tabelle AppSyncTutorial-Post genau mit dem Format des Post-Typs in GraphQL übereinstimmt, übergibt die Zuweisungsvorlage für die Antwort die Ergebnisse einfach direkt. Beachten Sie auch, dass in allen Beispielen in diesem Tutorial die gleiche Zuweisungsvorlage für Antworten verwendet wird, sodass Sie nur eine Datei erstellen müssen.
Wählen Sie Speichern aus.

Aufrufen der API zum Hinzufügen eines Posts

Jetzt, da der Resolver eingerichtet ist, AWS AppSync kann er eine eingehende addPost Mutation in eine PutItem DynamoDB-Operation übersetzen. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle hinzuzufügen.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Die Ergebnisse des neu erstellten Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Folgendes wurden ausgeführt:

AWS AppSync hat eine Mutationsanfrage erhalten. addPost

AWS AppSync hat die Anfrage und die Vorlage für die Anforderungszuweisung entgegengenommen und ein Dokument zur Anforderungszuweisung generiert. Dies sieht wie folgt aus:


{
    "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 hat das Anforderungszuordnungsdokument verwendet, um eine PutItem DynamoDB-Anforderung zu generieren und auszuführen.

AWS AppSync nahm die Ergebnisse der PutItem Anfrage und konvertierte sie wieder in GraphQL-Typen.


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

Dann wurden sie über das Antwortzuweisungsdokument unverändert weiter übergeben.
Das neu erstellte Objekt wurde in der GraphQL-Antwort zurückgegeben.

Einrichtung des GetPost-Resolvers (DynamoDB) GetItem

Jetzt, da Sie der AppSyncTutorial-Post DynamoDB-Tabelle Daten hinzufügen können, müssen Sie die getPost Abfrage so einrichten, dass sie diese Daten aus der AppSyncTutorial-Post Tabelle abrufen kann. Hierzu richten Sie einen weiteren Resolver ein.

Wählen Sie die Registerkarte Schema aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das Feld getPost des Typs Query (Abfrage) und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.

Aufrufen der API zum Abrufen eines Posts

Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende getPost Abfrage in eine GetItem DynamoDB-Operation übersetzt. Sie können jetzt eine Abfrage ausführen, um den zuvor erstellten Post abzurufen.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie im Bereich Abfragen Folgendes ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der von DynamoDB abgerufene Beitrag sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Folgendes wurden ausgeführt:

AWS AppSync hat eine getPost Abfrageanforderung erhalten.
AWS AppSync hat die Anfrage und die Vorlage für die Anforderungszuweisung entgegengenommen und ein Dokument zur Anforderungszuweisung generiert. Dies sieht wie folgt aus:
```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "123" }
    }
}
```
AWS AppSync hat das Anforderungszuordnungsdokument verwendet, um eine GetItem DynamoDB-Anforderung zu generieren und auszuführen.

AWS AppSync nahm die Ergebnisse der GetItem Anfrage und konvertierte sie wieder in GraphQL-Typen.


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

Dann wurden sie über das Antwortzuweisungsdokument unverändert weiter übergeben.
Das abgerufene Objekt wurde in der Antwort zurückgegeben.

Nehmen Sie alternativ das folgende Beispiel:


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

Wenn Ihre getPost Abfrage nur dasid, und benötigtauthor, können Sie Ihre Anforderungszuordnungsvorlage so änderntitle, dass Projektionsausdrücke verwendet werden, um nur die gewünschten Attribute aus Ihrer DynamoDB-Tabelle anzugeben, um unnötige Datenübertragungen von DynamoDB zu zu zu vermeiden. AWS AppSync Die Vorlage für die Anforderungszuweisung könnte beispielsweise wie der folgende Ausschnitt aussehen:


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

Eine UpdatePost-Mutation erstellen (DynamoDB) UpdateItem

Bisher können Sie Post Objekte in DynamoDB erstellen und abrufen. Als Nächstes richten Sie eine neue Mutation ein, um ein Objekt zu aktualisieren. Dazu verwenden Sie die UpdateItem DynamoDB-Operation.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Mutation Typ, um eine neue updatePost Mutation hinzuzufügen, wie folgt:


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

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld updatePost des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.
Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:
```
{
    "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 }
        }
    }
}
```
Hinweis: Dieser Resolver verwendet DynamoDB UpdateItem, was sich erheblich von der Operation unterscheidet. PutItem Anstatt das gesamte Element zu schreiben, bitten Sie DynamoDB lediglich, bestimmte Attribute zu aktualisieren. Dies erfolgt mithilfe von DynamoDB-Aktualisierungsausdrücken. Der Ausdruck selbst wird im Feld expression im Abschnitt update angegeben. Er gibt an, dass die Attribute author, title, content und "url" festgelegt werden sollen und dann das Feld version inkrementiert werden soll. Die zu verwendenden Werte werden nicht im Ausdruck selbst angegeben. Der Ausdruck enthält Platzhalter, deren Namen mit einem Doppelpunkt beginnen. Diese werden dann im Feld expressionValues definiert. Schließlich hat DynamoDB reservierte Wörter, die nicht in der vorkommen dürfen. expression url ist beispielsweise ein reservierter Begriff. Zum Aktualisieren des Felds url können Sie daher Platzhalter für Namen verwenden und sie im Feld expressionNames definieren.

Weitere Informationen zur UpdateItem Anforderungszuordnung finden Sie in der UpdateItemReferenzdokumentation. Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der DynamoDB-Dokumentation UpdateExpressions .
Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```

Aufrufen der API zum Aktualisieren eines Posts

Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende update Mutation in eine Update DynamoDB-Operation übersetzt. Sie können jetzt eine Mutation ausführen, um das zuvor geschriebene Element zu aktualisieren.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der aktualisierte Beitrag in DynamoDB sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "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 diesem Beispiel wurden die downs Felder ups und nicht geändert, da die Vorlage für die Anforderungszuweisung DynamoDB nicht AWS AppSync aufforderte, irgendetwas mit diesen Feldern zu tun. Außerdem wurde das version Feld um 1 erhöht, weil Sie DynamoDB gebeten AWS AppSync haben, dem Feld 1 hinzuzufügen. version

Ändern des UpdatePost-Resolvers (DynamoDB) UpdateItem

Dies war ein erfolgreicher Start für die updatePost-Mutation, es gibt aber zwei wesentliche Probleme:

Auch wenn nur ein einzelnes Feld aktualisiert werden soll, müssen alle Felder aktualisiert werden.
Wenn zwei Benutzer das Objekt ändern, können Informationen verloren gehen.

Um diese Probleme zu beheben, ändern wir die updatePost-Mutation so, dass nur Argumente geändert werden, die in der Anforderung angegeben wurden. Dann fügen wir der UpdateItem-Operation eine Bedingung hinzu.

Wählen Sie die Registerkarte Schema aus.
Ändern Sie im Bereich Schema das Feld updatePost im Typ Mutation, um die Ausrufungszeichen aus den Argumenten author, title, content und url zu entfernen. Achten Sie dabei darauf, das Feld id nicht zu ändern. Hierdurch werden die Argumente optional. Fügen Sie außerdem ein neues erforderliches expectedVersion-Argument hinzu.
```
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!
}
```
Wählen Sie Speichern aus.
Suchen Sie im Bereich Data types (Datentypen) auf der rechten Seite das Feld updatePost des Typs Mutation.
Wählen Sie PostDynamoDbTable, um den vorhandenen Resolver zu öffnen.

Ändern Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) folgendermaßen die Anforderungszuweisungsvorlage:


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

Wählen Sie Speichern aus.

Diese Vorlage ist eines der komplexeren Beispiele. Es zeigt die Leistung und Flexibilität der Zuweisungsvorlagen. Es durchläuft alle Argumente und springt dann zu id und expectedVersion. Wenn das Argument auf etwas gesetzt ist, fordert AWS AppSync es DynamoDB auf, dieses Attribut für das Objekt in DynamoDB zu aktualisieren. Wenn das Attribut auf Null gesetzt ist, fordert AWS AppSync es DynamoDB auf, dieses Attribut aus dem Post-Objekt zu entfernen. Wenn ein Argument nicht angegeben wurde, wird das Attribut nicht geändert. Außerdem wird das Feld version inkrementiert.

Außerdem gibt es einen neuen condition-Abschnitt. Ein Bedingungsausdruck ermöglicht es Ihnen AWS AppSync , DynamoDB anhand des Status des Objekts, das sich bereits vor der Ausführung des Vorgangs in DynamoDB befand, mitzuteilen, ob die Anforderung erfolgreich sein soll oder nicht. In diesem Fall möchten Sie, dass die UpdateItem Anfrage nur erfolgreich ist, wenn das version Feld des Elements, das sich derzeit in DynamoDB befindet, genau mit dem expectedVersion Argument übereinstimmt.

Weitere Informationen zu Bedingungsausdrücken finden Sie in der Bedingungsausdrücke-Referenzdokumentation.

Aufrufen der API zum Aktualisieren eines Posts

Aktualisieren wir nun unser Post-Objekt mit dem neuen Resolver:

Wählen Sie die Registerkarte Queries aus.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der aktualisierte Beitrag in DynamoDB sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "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 dieser Anfrage haben Sie DynamoDB gebeten AWS AppSync , nur das content Feld title und zu aktualisieren. Alle anderen Felder bleiben unverändert (nur das Feld version wird inkrementiert). Das title-Attribut wurde auf einen neuen Wert festgelegt und das content-Attribut wurde aus dem Post entfernt. Die Felder author, url, ups und downs blieben unverändert.

Führen Sie die Mutationsanforderung erneut aus und belassen Sie sie dabei unverändert. Es wird eine Antwort ähnlich der folgenden angezeigt:


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

Die Anforderung schlägt fehl, weil der Bedingungsausdruck als "false" ausgewertet wird:

Als Sie die Anfrage zum ersten Mal ausgeführt haben, war der Wert des version Felds des Beitrags in DynamoDB2, der expectedVersion dem Argument entsprach. Die Anfrage war erfolgreich, was bedeutete, dass das version Feld in DynamoDB auf inkrementiert wurde. 3
Als Sie die Anfrage zum zweiten Mal ausgeführt haben, war der Wert des version Felds des Beitrags in DynamoDB3, der nicht mit dem expectedVersion Argument übereinstimmte.

Dieses Muster wird normalerweise als optimistische Sperre bezeichnet.

Ein Merkmal eines AWS AppSync DynamoDB-Resolvers besteht darin, dass er den aktuellen Wert des Post-Objekts in DynamoDB zurückgibt. Sie finden dies im Feld data im Abschnitt errors der GraphQL-Antwort. Ihre Anwendung kann anhand dieser Informationen entscheiden, wie weiter vorgegangen werden soll. In diesem Fall können Sie sehen, dass das version Feld des Objekts in DynamoDB auf 3 gesetzt ist. Sie könnten also das expectedVersion Argument einfach auf aktualisieren 3 und die Anfrage wäre wieder erfolgreich.

Weitere Informationen zum Behandeln von Fehlern bei Bedingungsprüfungen finden Sie in der Zuweisungsvorlagen-Referenzdokumentation für Bedingungsausdrücke.

UpvotePost- und DownvotePost-Mutationen erstellen (DynamoDB) UpdateItem

Der Typ Post verfügt über die Felder ups und downs, mit denen Upvotes und Downvotes erfasst werden können. In der API können sie allerdings derzeit nicht verwendet werden. Fügen Sie daher einige Mutationen hinzu, um Upvotes und Downvotes für die Posts zu ermöglichen.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Mutation Typ, um neue Mutationen hinzuzufügen, wie folgt: 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!
}

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld upvotePost des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld downvotePost des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Feld Datenquellenname die Option PostDynamoDBTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.

Aufrufen der API für ein Upvote oder Downvote eines Posts

Jetzt wurden die neuen Resolver eingerichtet, AWS AppSync weiß, wie man eine eingehende Operation upvotePost oder eine downvote Mutation in eine UpdateItem DynamoDB-Operation übersetzt. Sie können jetzt Mutationen ausführen, um Upvotes oder Downvotes für den zuvor erstellten Post auszuführen.

Wählen Sie die Registerkarte Queries aus.
Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation votePost {
  upvotePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der Beitrag wurde in DynamoDB aktualisiert und sollte im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Wählen Sie Execute query (Abfrage ausführen) einige weitere Male. Jedes Mal, wenn Sie die Abfrage ausführen, sollten die Felder ups und version um 1 erhöht werden.

Ändern Sie folgendermaßen die Abfrage zum Aufrufen der downvotePost-Mutation:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche). Jedes Mal, wenn Sie die Abfrage ausführen, sollten jetzt die Felder downs und version um 1 erhöht werden.


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

Den DeletePost-Resolver einrichten (DynamoDB) DeleteItem

Mit der nächsten Mutation, die Sie einrichten möchten, soll ein Post gelöscht werden. Dazu verwenden Sie die DeleteItem DynamoDB-Operation.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Mutation Typ, um eine neue deletePost Mutation hinzuzufügen, wie folgt:


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

Dieses Mal wurde das Feld expectedVersion als optional konfiguriert. Dies wird später erläutert, wenn Sie die Anforderungszuweisungsvorlage hinzufügen.

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld delete des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.
Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:
```
{
    "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
}
```
Hinweis: Das Argument expectedVersion ist ein optionales Argument. Wenn der Aufrufer ein expectedVersion Argument in der Anfrage festlegt, fügt die Vorlage eine Bedingung hinzu, die nur dann den Erfolg der DeleteItem Anfrage ermöglicht, wenn das Element bereits gelöscht wurde oder wenn das version Attribut des Beitrags in DynamoDB genau dem entspricht. expectedVersion Wenn es ausgelassen wird, wird kein Bedingungsausdruck für die DeleteItem-Anforderung angegeben. Es ist erfolgreichversion, unabhängig vom Wert von oder ob das Element in DynamoDB vorhanden ist oder nicht.
Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Hinweis: Auch wenn Sie ein Element löschen, können Sie das gelöschte Element zurückgeben, sofern es nicht bereits vorher gelöscht wurde.
Wählen Sie Speichern aus.

Weitere Informationen zur DeleteItem Anforderungszuordnung finden Sie in der DeleteItemReferenzdokumentation.

Aufrufen der API zum Löschen eines Posts

Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende delete Mutation in eine DeleteItem DynamoDB-Operation übersetzt. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle zu löschen.

Wählen Sie die Registerkarte Queries aus.
Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation deletePost {
  deletePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}
```
Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).
Der Beitrag wurde aus DynamoDB gelöscht. Beachten Sie, dass der Wert des Elements AWS AppSync zurückgegeben wird, das aus DynamoDB gelöscht wurde und der im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden sollte. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
  "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
    }
  }
}
```

Der Wert wird nur zurückgegeben, wenn dieser Aufruf von deletePost derjenige war, der ihn tatsächlich aus DynamoDB gelöscht hat.

Wählen Sie erneut Execute query (Abfrage ausführen).
Der Aufruf ist weiterhin erfolgreich, es wird jedoch kein Wert zurückgegeben.
```
{
  "data": {
    "deletePost": null
  }
}
```

Löschen wir jetzt einen Post. Dieses Mal geben wir aber einen expectedValue an. Zuerst müssen Sie jedoch einen neuen Post erstellen, da der Post, mit dem Sie bisher gearbeitet haben, gerade gelöscht wurde.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Die Ergebnisse des neu erstellten Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Notieren Sie die id des neu erstellten Objekts, da diese gleich benötigt wird. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Jetzt versuchen wir, diesen Post zu löschen, geben aber einen falschen Wert für expectedVersion an:

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.


mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 9999
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).


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

Die Anforderung ist fehlgeschlagen, weil der Bedingungsausdruck als falsch ausgewertet wird: Der Wert für version des Beitrags in DynamoDB entspricht nicht dem in den Argumenten expectedValue angegebenen Wert. Der aktuelle Wert des Objekts wird im Feld data im Abschnitt errors der GraphQL-Antwort zurückgegeben.

Wiederholen Sie die Anforderung und korrigieren Sie dabei expectedVersion:


mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Diesmal ist die Anfrage erfolgreich und der Wert, der aus DynamoDB gelöscht wurde, wird zurückgegeben:


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

Wählen Sie erneut Execute query (Abfrage ausführen).
Der Aufruf ist immer noch erfolgreich, aber diesmal wird kein Wert zurückgegeben, da der Beitrag bereits in DynamoDB gelöscht wurde.


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

Einrichten des allPost-Resolvers (DynamoDB Scan)

Bisher ist die API nur nützlich, wenn Sie die id eines jeden Beitrags kennen, den Sie betrachten möchten. Fügen wir jetzt einen neuen Resolver hinzu, der alle Posts in der Tabelle zurückgibt.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Query Typ, um eine neue allPost Abfrage hinzuzufügen, wie folgt:


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

Fügen Sie einen neuen PaginationPosts-Typ hinzu:


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

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld allPost des Typs Query (Abfrage) und wählen Sie dann Attach (Anhängen).
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.
Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:
```
{
    "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
}
```
Dieser Resolver verfügt über zwei optionale Argumente: count gibt die maximale Anzahl von Elementen an, die in einem Aufruf zurückgegeben werden sollen, und mit nextToken kann der nächste Ergebnissatz abgerufen werden. (Später wird erläutert, woher der Wert für nextToken stammt.)
Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Hinweis: Diese Zuweisungsvorlage für Antworten unterscheidet sich von allen bisher betrachteten Zuweisungsvorlagen. Das Ergebnis der allPost-Abfrage ist PaginatedPosts mit einer Liste von Posts und einem Paginierungs-Token. Die Form dieses Objekts unterscheidet sich von der Rückgabe des AWS AppSync -DynamoDB-Resolvers: die Liste der Posts wird im AWS AppSync -DynamoDB-Resolver als items bezeichnet, in PaginatedPosts wird sie als posts bezeichnet.
Wählen Sie Speichern aus.

Weitere Informationen zur Zuordnung von Scan Anfragen finden Sie in der Referenzdokumentation zum Scannen.

Aufrufen der API zum Scannen aller Posts

Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende allPost Abfrage in eine Scan DynamoDB-Operation übersetzt. Sie können jetzt die Tabelle scannen, um alle Posts abzurufen.

Bevor Sie dies ausprobieren können, muss allerdings die Tabelle mit Daten gefüllt werden, da Sie alle Daten gelöscht haben, mit denen Sie bislang gearbeitet haben.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Scannen wir jetzt die Tabelle so, dass jeweils fünf Ergebnisse zurückgegeben werden.

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Die ersten fünf Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "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="
    }
  }
}

Sie haben fünf Ergebnisse und ein nextToken, das zum Abrufen des nächsten Ergebnissatzes verwendet werden kann.

Aktualisieren Sie die allPost-Abfrage, um das nextToken aus dem vorherigen Ergebnissatz einzuschließen:


query allPost {
  allPost(
    count: 5
    nextToken: "eyJ2ZXJzaW9uIjoxLCJ0b2tlbiI6IkFRSUNBSGo4eHR0RG0xWXhUa1F0cEhXMEp1R3B0M1B3eThOSmRvcG9ad2RHYjI3Z0lnRlluNktJRWl6V0ZlR3hJOVJkaStrZUFBQUI1akNDQWVJR0NTcUdTSWIzRFFFSEJxQ0NBZE13Z2dIUEFnRUFNSUlCeUFZSktvWklodmNOQVFjQk1CNEdDV0NHU0FGbEF3UUJMakFSQkF5cW8yUGFSZThnalFpemRCTUNBUkNBZ2dHWk1JODhUNzhIOFVUZGtpdFM2ZFluSWRyVDg4c2lkN1RjZzB2d1k3VGJTTWpSQ2U3WjY3TkUvU2I1dWNETUdDMmdmMHErSGJSL0pteGRzYzVEYnE1K3BmWEtBdU5jSENJdWNIUkJ0UHBPWVdWdCtsS2U5L1pNcWdocXhrem1RaXI1YnIvQkt6dU5hZmJCdE93NmtoM2Jna1BKM0RjWWhpMFBGbmhMVGg4TUVGSjBCcXg3RTlHR1V5N0tUS0JLZlV3RjFQZ0JRREdrNzFYQnFMK2R1S2IrVGtZZzVYMjFrc3NyQmFVTmNXZmhTeXE0ZUJHSWhqZWQ5c3VKWjBSSTc2ZnVQdlZkR3FLNENjQmxHYXhpekZnK2pKK1FneEU1SXduRTNYYU5TR0I4QUpmamR2bU1wbUk1SEdvWjlMUUswclczbG14RDRtMlBsaTNLaEVlcm9pem5zcmdINFpvcXIrN2ltRDN3QkJNd3BLbGQzNjV5Nnc4ZnMrK2FnbTFVOUlKOFFrOGd2bEgySHFROHZrZXBrMWlLdWRIQ25LaS9USnBlMk9JeEVPazVnRFlzRTRUU09HUlVJTkxYY2MvdW1WVEpBMUthV2hWTlAvdjNlSnlZQUszbWV6N2h5WHVXZ1BkTVBNWERQdTdjVnVRa3EwK3NhbGZOd2wvSUx4bHNyNDVwTEhuVFpyRWZvVlV1bXZ5S2VKY1RUU1lET05hM1NwWEd2UT09In0="
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Die verbleibenden vier Posts sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Dieser Ergebnissatz enthält kein nextToken, weil Sie alle neun Posts durchlaufen haben und keine mehr übrig sind. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Den allPostsBy Author Resolver einrichten (DynamoDB Query)

Sie können DynamoDB nicht nur nach allen Beiträgen durchsuchen, sondern auch DynamoDB abfragen, um Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden. Die DynamoDB-Tabelle, die Sie zuvor erstellt haben, hat bereits einen GlobalSecondaryIndex Aufruf, den author-index Sie mit einer Query DynamoDB-Operation verwenden können, um alle Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Query Typ, um eine neue allPostsByAuthor Abfrage hinzuzufügen, wie folgt:


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

Hinweis: Hier wird der gleiche PaginatedPosts-Typ wie in der allPost-Abfrage verwendet.

Wählen Sie Speichern aus.
Suchen Sie im Bereich Datentypen auf der rechten Seite nach dem neu erstellten allPostsByAutorenfeld für den Abfragetyp, und wählen Sie dann Anhängen aus.
Wählen Sie im Menü Aktion die Option Laufzeit aktualisieren und anschließend Unit Resolver (nur VTL) aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamo DbTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Dieser Resolver verfügt wie der allPost-Resolver über zwei optionale Argumente: count gibt die maximale Anzahl von Elementen an, die in einem Aufruf zurückgegeben werden sollen, und mit nextToken kann der nächste Ergebnissatz abgerufen werden. (Der Wert für nextToken kann aus einem vorherigen Abruf übernommen werden.)

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
{
    "posts": $utils.toJson($context.result.items)
    #if( ${context.result.nextToken} )
        ,"nextToken": $util.toJson($context.result.nextToken)
    #end
}
```
Hinweis: Dies ist die gleiche Zuweisungsvorlage für Antworten, die auch im allPost-Resolver verwendet wurde.
Wählen Sie Speichern aus.

Weitere Informationen zur Query Anforderungszuordnung finden Sie in der Query-Referenzdokumentation.

Aufrufen der API zum Abfragen aller Posts von einem Autor

Jetzt ist der Resolver eingerichtet und AWS AppSync weiß, wie man eine eingehende allPostsByAuthor Mutation in eine Query DynamoDB-Operation gegen den Index übersetzt. author-index Sie können nun die Tabelle abfragen, um alle Posts von einem bestimmten Autor abzurufen.

Zuvor müssen Sie jedoch die Tabelle mit weiteren Post-Daten füllen, da bisher alle Posts den gleichen Autor haben.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Wir fragen jetzt die Tabelle ab, so dass alle Posts von Nadia zurückgegeben werden.

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle Posts von Nadia sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you know...?"
        }
      ],
      "nextToken": null
    }
  }
}

Die Paginierung funktioniert für Query genauso wie für Scan. Suchen wir z. B. nach allen Posts von AUTHORNAME, wobei jeweils fünf Posts abgerufen werden.

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle Posts von AUTHORNAME sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "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=="
    }
  }
}

Aktualisieren Sie das nextToken-Argument mit dem Wert, der in der vorherigen Abfrage zurückgegeben wurde:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle verbleibenden Posts von AUTHORNAME sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Verwenden von Sätzen

Bis zu diesem Punkt war der Typ Post ein flaches Schlüssel/Wert-Objekt. Sie können mit dem AWS AppSyncDynamo DB-Resolver auch komplexe Objekte wie Gruppen, Listen und Maps modellieren.

Aktualisieren wir jetzt den Post-Typ, so dass er Tags enthält. Ein Beitrag kann 0 oder mehr Tags haben, die in DynamoDB als String-Set gespeichert werden. Außerdem richten Sie einige Mutationen ein, um Tags hinzuzufügen und zu entfernen, sowie eine neue Abfrage zum Scannen nach Posts mit einem bestimmten Tag.

Wählen Sie die Registerkarte Schema aus.

Ändern Sie im Schemabereich den Post Typ wie folgt, um ein neues tags Feld hinzuzufügen:


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

Ändern Sie im Schemabereich den Query Typ, um eine neue allPostsByTag Abfrage hinzuzufügen, wie folgt:


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
}

Ändern Sie im Schemabereich den Mutation Typ, um neue addTag und removeTag Mutationen hinzuzufügen, wie folgt:


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

Wählen Sie Speichern aus.
Suchen Sie im Bereich Datentypen auf der rechten Seite nach dem neu erstellten allPostsByTag-Feld für den Abfragetyp, und wählen Sie dann Anhängen aus.
Wählen Sie im Feld Datenquellenname die Option PostDynamoDBTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:


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

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld addTag des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Feld Datenquellenname die Option PostDynamoDBTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld removeTag des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Feld Datenquellenname die Option PostDynamoDBTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.

Aufrufen der API zum Arbeiten mit Tags

Nachdem Sie die Resolver eingerichtet haben, AWS AppSync weiß er, wie eingehende addTag allPostsByTag Anfragen und Anfragen in DynamoDB UpdateItem und Operationen übersetzt werden. removeTag Scan

Wählen Sie zum Ausprobieren einen der zuvor erstellten Posts aus. Verwenden wir als Beispiel einen Post, der von Nadia verfasst wurde.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle Posts von Nadia sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


{
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you known...?"
        }
      ],
      "nextToken": null
    }
  }
}

Verwenden wir den Post mit dem Titel "The cutest dog in the world". Notieren Sie dessen id, da diese später benötigt wird.

Fügen wir jetzt den Tag dog hinzu.

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation addTag {
  addTag(id:10 tag: "dog") {
    id
    title
    tags
  }
}
```
Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der Post wird mit dem neuen Tag aktualisiert.


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

Sie können weitere Tags folgendermaßen hinzufügen:

Aktualisieren Sie die Mutation und ändern Sie das tag-Argument in puppy.


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der Post wird mit dem neuen Tag aktualisiert.


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

Tags können auch gelöscht werden:

Fügen Sie die folgende Mutation in den Bereich Queries (Abfragen) ein. Außerdem müssen Sie das id-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}
```
Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Der Post wird aktualisiert und das Tag puppy wird gelöscht.


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

Sie können auch alle Posts mit einem Tag suchen:

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle Posts mit dem Tag dog werden folgendermaßen zurückgegeben:


{
  "data": {
    "allPostsByTag": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world",
          "tags": [
            "dog",
            "puppy"
          ]
        }
      ],
      "nextToken": null
    }
  }
}

Verwenden von Listen und Zuordnungen

Neben DynamoDB-Sets können Sie auch DynamoDB-Listen und -Maps verwenden, um komplexe Daten in einem einzigen Objekt zu modellieren.

Fügen wir nun die Möglichkeit hinzu, Posts Kommentare hinzuzufügen. Dies wird als Liste von Kartenobjekten für das Post Objekt in DynamoDB modelliert.

Hinweis: In einer realen Anwendung würden Sie Kommentare in der eigenen Tabelle modellieren. Für dieses Tutorial fügen Sie sie einfach in die Post-Tabelle ein.

Wählen Sie die Registerkarte Schema aus.
Fügen Sie im Bereich Schema folgendermaßen einen neuen Comment-Typ hinzu:
```
type Comment {
    author: String!
    comment: String!
}
```

Ändern Sie im Schemabereich den Post Typ wie folgt, um ein neues comments Feld hinzuzufügen:


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

Ändern Sie im Schemabereich den Mutation Typ wie folgt, um eine neue addComment Mutation hinzuzufügen:


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

Wählen Sie Speichern aus.
Suchen Sie rechts im Bereich Data types (Datentypen) das neue Feld addComment des Typs Mutation und wählen Sie dann Attach (Anhängen).
Wählen Sie im Feld Datenquellenname die Option PostDynamoDBTable aus.

Fügen Sie unter Configure the request mapping template (Zuweisungsvorlage für Anforderungen konfigurieren) Folgendes ein:


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

Dieser Aktualisierungsausdruck fügt eine Liste mit dem neuen Kommentar an die vorhandene comments-Liste an. Wenn die Liste noch nicht vorhanden ist, wird sie erstellt.

Fügen Sie unter Configure the response mapping template (Zuweisungsvorlage für Antworten konfigurieren) Folgendes ein:
```
$utils.toJson($context.result)
```
Wählen Sie Speichern aus.

Aufrufen der API zum Hinzufügen eines Kommentars

Jetzt, wo Sie die Resolver eingerichtet haben, AWS AppSync weiß, wie eingehende addComment Anfragen in UpdateItem DynamoDB-Operationen übersetzt werden.

Fügen Sie zum Ausprobieren einen Kommentar zu dem Post hinzu, dem auch die Tags hinzugefügt wurden.

Wählen Sie die Registerkarte Queries aus.

Fügen Sie im Bereich Queries (Abfragen) die folgende Abfrage ein:


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

Wählen Sie Execute query (Abfrage ausführen) (orangefarbene Wiedergabeschaltfläche).

Alle Posts von Nadia sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:


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

Wenn Sie die Anforderung mehrmals ausführen, werden mehrere Kommentare an die Liste angefügt.

Schlussfolgerung

In diesem Tutorial haben Sie eine API erstellt, mit der wir Post-Objekte in DynamoDB mithilfe AWS AppSync von GraphQL bearbeiten können. Weitere Informationen finden Sie unter Referenz für Resolver-Zuweisungsvorlagen.

Zum Aufräumen können Sie die AppSync GraphQL-API von der Konsole löschen.

Um die DynamoDB-Tabelle und die IAM-Rolle zu löschen, die Sie für dieses Tutorial erstellt haben, können Sie Folgendes ausführen, um den AWSAppSyncTutorialForAmazonDynamoDB Stack zu löschen, oder die AWS CloudFormation Konsole aufrufen und den Stack löschen:


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Resolver-Tutorials (VTL)

Tutorial: Lambda-Resolver