Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Erstellen einer einfachen Post-Anwendung mit DynamoDB-Resolvern JavaScript
In diesem Tutorial importieren Sie Ihre Amazon DynamoDB-Tabellen in AWS AppSync und verbinden sie, um mithilfe von JavaScript Pipeline-Resolvern, die Sie in Ihrer eigenen Anwendung nutzen können, eine voll funktionsfähige GraphQL-API zu erstellen.
Sie verwenden die AWS AppSync Konsole, um Ihre Amazon DynamoDB DynamoDB-Ressourcen bereitzustellen, Ihre Resolver zu erstellen und sie mit Ihren Datenquellen zu verbinden. Sie werden auch in der Lage sein, über GraphQL-Anweisungen in Ihre Amazon DynamoDB DynamoDB-Datenbank zu lesen und in sie zu schreiben und Echtzeitdaten zu abonnieren.
Es gibt bestimmte Schritte, die abgeschlossen werden müssen, damit GraphQL-Anweisungen in Amazon DynamoDB DynamoDB-Operationen und Antworten wieder in GraphQL übersetzt werden können. In diesem Tutorial wird der Konfigurationsprozess anhand mehrerer Szenarien und Datenzugriffsmuster aus der Praxis veranschaulicht.
## Erstellen Sie Ihre GraphQL-API
**Um eine GraphQL-API zu erstellen in AWS AppSync**
1. Öffnen Sie die AppSync Konsole und wählen Sie **Create API**.
1. Wählen Sie **Von Grund auf neu entwerfen** und **dann Weiter**.
1. Geben Sie Ihrer API `PostTutorialAPI` einen Namen und wählen Sie dann **Weiter**. Gehen Sie zur Bewertungsseite, behalten Sie für die übrigen Optionen die Standardwerte bei und wählen Sie`Create`.
Die AWS AppSync Konsole erstellt eine neue GraphQL-API für Sie. Standardmäßig wird der API-Schlüsselauthentifizierungsmodus verwendet. Sie können in der Konsole den Rest der GraphQL-API einrichten und im weiteren Verlauf dieses Tutorials abfragen.
## Definition einer grundlegenden Post-API
Jetzt, wo Sie Ihre GraphQL-API haben, können Sie ein grundlegendes Schema einrichten, das das grundlegende Erstellen, Abrufen und Löschen von Post-Daten ermöglicht.
**Um Daten zu Ihrem Schema hinzuzufügen**
1. Wählen Sie in Ihrer API die Registerkarte **Schema**.
1. Wir werden ein Schema erstellen, das einen `Post` Typ und eine Operation `addPost` zum Hinzufügen und Abrufen von `Post` Objekten definiert. 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!
}
```
1. Wählen Sie **Save Schema (Schema speichern)**.
## Einrichtung Ihrer Amazon DynamoDB-Tabelle
Die AWS AppSync Konsole kann Ihnen helfen, die AWS Ressourcen bereitzustellen, die Sie zum Speichern Ihrer eigenen Ressourcen in einer Amazon DynamoDB-Tabelle benötigen. In diesem Schritt erstellen Sie eine Amazon DynamoDB-Tabelle zum Speichern Ihrer Beiträge. Sie richten auch einen [sekundären Index](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) ein, den wir später verwenden werden.
**So erstellen Sie Ihre Amazon DynamoDB-Tabelle**
1. Wählen Sie auf der **Schemaseite** **Create** Resources aus.
1. Wählen Sie **Bestehenden Typ verwenden** und wählen Sie dann den `Post` Typ aus.
1. Wählen Sie im Abschnitt **Zusätzliche Indizes** die Option **Index hinzufügen** aus.
1. Benennen Sie den Index`author-index`.
1. Stellen Sie `Primary key` das Auf `author` und den `Sort` Schlüssel auf ein`None`.
1. Deaktivieren Sie **GraphQL automatisch generieren**. In diesem Beispiel erstellen wir den Resolver selbst.
1. Wählen Sie **Erstellen** aus.
Sie haben jetzt eine neue Datenquelle namens`PostTable`, die Sie unter **Datenquellen** auf der seitlichen Registerkarte einsehen können. Sie verwenden diese Datenquelle, um Ihre Abfragen und Mutationen mit Ihrer Amazon DynamoDB-Tabelle zu verknüpfen.
## Einen AddPost-Resolver einrichten (Amazon DynamoDB) PutItem
Da Sie AWS AppSync nun die Amazon DynamoDB-Tabelle kennen, können Sie sie mit einzelnen Abfragen und Mutationen verknüpfen, indem Sie Resolver definieren. Der erste Resolver, den Sie erstellen, ist der verwendete `addPost` Pipeline-Resolver JavaScript, mit dem Sie einen Beitrag in Ihrer Amazon DynamoDB-Tabelle erstellen können. Ein Pipeline-Resolver besteht aus den folgenden Komponenten:
+ Die Stelle im GraphQL-Schema, an der der Resolver angefügt werden soll. In diesem Fall richten Sie einen Resolver im Feld `createPost` im Typ `Mutation` ein. Dieser Resolver wird aufgerufen, wenn der Aufrufer Mutation aufruft. `{ addPost(...){...} }`
+ Die Datenquelle für diesen Resolver. In diesem Fall möchten Sie die zuvor definierte DynamoDB-Datenquelle verwenden, damit Sie der `post-table-for-tutorial` DynamoDB-Tabelle Einträge hinzufügen können.
+ Der Request-Handler. Der Request-Handler ist eine Funktion, die die eingehende Anfrage des Aufrufers verarbeitet und sie in Anweisungen AWS AppSync zur Ausführung gegen DynamoDB übersetzt.
+ Der Antworthandler. Die Aufgabe des Response-Handlers besteht darin, die Antwort von DynamoDB zu verarbeiten und sie wieder in etwas zu übersetzen, das 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.
**Um Ihren Resolver einzurichten**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Suchen Sie im Bereich **Resolver** nach dem `addPost` Feld unter dem `Mutation` Typ und wählen Sie dann **Attach** aus.
1. Wählen Sie Ihre Datenquelle und dann **Erstellen** aus.
1. Ersetzen Sie den Code in Ihrem Code-Editor durch diesen Codeausschnitt:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 }
const key = { id: ctx.args.id ?? util.autoId() }
return ddb.put({ key, item })
}
export function response(ctx) {
return ctx.result
}
```
1. Wählen Sie **Speichern**.
**Anmerkung**
In diesem Code verwenden Sie die DynamoDB-Modul-Utils, mit denen Sie auf einfache Weise DynamoDB-Anfragen erstellen können.
AWS AppSync enthält ein Hilfsprogramm zur automatischen ID-Generierung namens`util.autoId()`, das verwendet wird, um eine ID für Ihren neuen Beitrag zu generieren. Wenn Sie keine ID angeben, generiert das Tool sie automatisch für Sie.
```
const key = { id: ctx.args.id ?? util.autoId() }
```
Weitere Informationen zu den verfügbaren Dienstprogrammen für JavaScript finden Sie unter [JavaScriptLaufzeitfunktionen für Resolver und Funktionen](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
### Rufen Sie die API auf, um einen Beitrag hinzuzufügen
Jetzt, da der Resolver konfiguriert wurde, AWS AppSync kann er eine eingehende `addPost` Mutation in einen Amazon DynamoDB DynamoDB-Vorgang `PutItem` übersetzen. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle hinzuzufügen.
**Um den Vorgang auszuführen**
1. Wählen Sie in Ihrer API die Registerkarte **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu:
```
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
}
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend`addPost`. Die Ergebnisse des neu erstellten Beitrags 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
}
}
}
```
Die folgende Erklärung zeigt, was passiert ist:
1. AWS AppSync hat eine `addPost` Mutationsanfrage erhalten.
1. AWS AppSync führt den Request-Handler des Resolvers aus. Die `ddb.put` Funktion erstellt eine `PutItem` Anfrage, die wie folgt aussieht:
```
{
operation: 'PutItem',
key: { id: { S: '123' } },
attributeValues: {
downs: { N: 0 },
author: { S: 'AUTHORNAME' },
ups: { N: 1 },
title: { S: 'Our first post!' },
version: { N: 1 },
content: { S: 'This is our first post.' },
url: { S: 'https://aws.amazon.com/appsync/' }
}
}
```
1. AWS AppSync verwendet diesen Wert, um eine Amazon DynamoDB `PutItem` DynamoDB-Anfrage zu generieren und auszuführen.
1. 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
}
```
1. Der Antworthandler gibt das Ergebnis sofort zurück (`return ctx.result`).
1. Das Endergebnis ist in der GraphQL-Antwort sichtbar.
## Einrichtung des GetPost-Resolvers (Amazon DynamoDB) GetItem
Jetzt, da Sie der Amazon DynamoDB-Tabelle Daten hinzufügen können, müssen Sie die `getPost` Abfrage so einrichten, dass sie diese Daten aus der Tabelle abrufen kann. Hierzu richten Sie einen weiteren Resolver ein.
**Um Ihren Resolver hinzuzufügen**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite das `getPost` Feld für den `Query` Typ und wählen Sie dann **Attach** aus.
1. Wählen Sie Ihre Datenquelle und dann **Erstellen** aus.
1. Ersetzen Sie den Code im Code-Editor durch diesen Codeausschnitt:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({ key: { id: ctx.args.id } })
}
export const response = (ctx) => ctx.result
```
1. Speichern Sie Ihren Resolver.
**Anmerkung**
In diesem Resolver verwenden wir einen Pfeilfunktionsausdruck für den Antworthandler.
### Rufen Sie die API auf, um einen Beitrag zu erhalten
Jetzt, da der Resolver eingerichtet wurde, AWS AppSync weiß er, wie eine eingehende `getPost` Anfrage in einen Amazon DynamoDB `GetItem` DynamoDB-Vorgang übersetzt wird. Sie können jetzt eine Abfrage ausführen, um den zuvor erstellten Post abzurufen.
**Um Ihre Abfrage auszuführen**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** den folgenden Code hinzu und verwenden Sie die ID, die Sie nach der Erstellung Ihres Beitrags kopiert haben:
```
query getPost {
getPost(id: "123") {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wähle „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und dann`getPost`. Die Ergebnisse des neu erstellten Beitrags sollten im **Ergebnisbereich** rechts neben dem **Abfragebereich angezeigt** werden.
1. Der von Amazon 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
}
}
}
```
Nehmen Sie alternativ das folgende Beispiel:
```
query getPost {
getPost(id: "123") {
id
author
title
}
}
```
Wenn Ihre `getPost` Abfrage nur das`id`, und benötigt`author`, können Sie Ihre Anforderungsfunktion so ändern`title`, 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 Anforderungsfunktion könnte beispielsweise wie der folgende Ausschnitt aussehen:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({
key: { id: ctx.args.id },
projection: ['author', 'id', 'title'],
})
}
export const response = (ctx) => ctx.result
```
Sie können auch ein [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js)mit verwenden`getPost`, um Folgendes darzustellen: `expression`
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.'))
return ddb.get({ key: { id: ctx.args.id }, projection })
}
export const response = (ctx) => ctx.result
```
## Eine UpdatePost-Mutation erstellen (Amazon DynamoDB) UpdateItem
Bisher können Sie `Post` Objekte in Amazon DynamoDB erstellen und abrufen. Als Nächstes richten Sie eine neue Mutation ein, um ein Objekt zu aktualisieren. Im Vergleich zu der `addPost` Mutation, bei der alle Felder angegeben werden müssen, können Sie mit dieser Mutation nur die Felder angeben, die Sie ändern möchten. Außerdem wurde ein neues `expectedVersion` Argument eingeführt, mit dem Sie die Version angeben können, die Sie ändern möchten. Sie richten eine Bedingung ein, die sicherstellt, dass Sie die neueste Version des Objekts ändern. Dazu verwenden Sie die `UpdateItem` Amazon DynamoDB DynamoDB-Operation.sc
**Um Ihren Resolver zu aktualisieren**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Ä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,
expectedVersion: Int!
): Post
addPost(
id: ID
author: String!
title: String!
content: String!
url: String!
): Post!
}
```
1. Wählen Sie **Save Schema (Schema speichern)**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `updatePost` Feld für den `Mutation` Typ und wählen Sie dann **Anhängen** aus. Erstellen Sie Ihren neuen Resolver mithilfe des folgenden Snippets:
```
import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { id, expectedVersion, ...rest } = ctx.args;
const values = Object.entries(rest).reduce((obj, [key, value]) => {
obj[key] = value ?? ddb.operations.remove();
return obj;
}, {});
return ddb.update({
key: { id },
condition: { version: { eq: expectedVersion } },
update: { ...values, version: ddb.operations.increment(1) },
});
}
export function response(ctx) {
const { error, result } = ctx;
if (error) {
util.appendError(error.message, error.type);
}
return result;
```
1. Speichern Sie alle Änderungen, die Sie vorgenommen haben.
Dieser Resolver wird verwendet`ddb.update`, um eine Amazon DynamoDB `UpdateItem` DynamoDB-Anfrage zu erstellen. Anstatt den gesamten Artikel zu schreiben, bitten Sie Amazon DynamoDB lediglich, bestimmte Attribute zu aktualisieren. Dies erfolgt mithilfe von Amazon DynamoDB DynamoDB-Aktualisierungsausdrücken.
Die `ddb.update` Funktion verwendet einen Schlüssel und ein Aktualisierungsobjekt als Argumente. Anschließend überprüfen Sie die Werte der eingehenden Argumente. Wenn ein Wert auf gesetzt ist`null`, verwenden Sie die `remove` DynamoDB-Operation, um zu signalisieren, dass der Wert aus dem DynamoDB-Element entfernt werden soll.
Es gibt auch einen neuen Abschnitt. `condition` Ein Bedingungsausdruck ermöglicht es Ihnen, Amazon DynamoDB mitzuteilen AWS AppSync , ob die Anfrage erfolgreich sein soll, basierend auf dem Zustand des Objekts, das sich bereits in Amazon DynamoDB befand, bevor der Vorgang ausgeführt wird. In diesem Fall möchten Sie, dass die `UpdateItem` Anfrage nur erfolgreich ist, wenn das `version` Feld des Elements, das sich derzeit in Amazon DynamoDB befindet, genau mit dem `expectedVersion` Argument übereinstimmt. Wenn der Artikel aktualisiert wird, möchten wir den Wert von erhöhen. `version` Dies ist mit der Bedienfunktion `increment` einfach zu bewerkstelligen.
Weitere Informationen zu Bedingungsausdrücken finden Sie in der Dokumentation zu [Bedingungsausdrücken](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions).
Weitere Informationen zu der `UpdateItem` Anfrage finden Sie in der [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)Dokumentation und in der Dokumentation zum [DynamoDB-Modul](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html).
Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der [DynamoDB-Dokumentation UpdateExpressions](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html).
### Rufen Sie die API auf, um einen Beitrag zu aktualisieren
Versuchen wir, das `Post` Objekt mit dem neuen Resolver zu aktualisieren.
**Um dein Objekt zu aktualisieren**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id` Argument auf den Wert aktualisieren, den Sie sich zuvor notiert haben:
```
mutation updatePost {
updatePost(
id:123
title: "An empty story"
content: null
expectedVersion: 1
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann`updatePost`.
1. Der aktualisierte Beitrag in Amazon DynamoDB sollte im **Ergebnisbereich** rechts neben dem Bereich **Abfragen 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": 2
}
}
}
```
In dieser Anfrage haben Sie Amazon DynamoDB gebeten AWS AppSync , nur die `content` Felder `title` und zu aktualisieren. Alle anderen Felder wurden unverändert gelassen (mit Ausnahme der Erhöhung des `version` Felds). Sie haben das `title` Attribut auf einen neuen Wert gesetzt und das `content` Attribut aus dem Beitrag entfernt. Die Felder `author`, `url`, `ups` und `downs` blieben unverändert. Versuchen Sie erneut, die Mutationsanforderung auszuführen, während Sie die Anfrage genau so lassen, wie sie ist. Es wird eine Antwort ähnlich der folgenden angezeigt:
```
{
"data": {
"updatePost": null
},
"errors": [
{
"path": [
"updatePost"
],
"data": null,
"errorType": "DynamoDB:ConditionalCheckFailedException",
"errorInfo": null,
"locations": [
{
"line": 2,
"column": 3,
"sourceName": null
}
],
"message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)"
}
]
}
```
Die Anforderung schlägt fehl, weil der Bedingungsausdruck wie folgt ausgewertet wird: `false`
1. Als Sie die Anfrage zum ersten Mal ausgeführt haben, war der Wert des `version` Felds des Beitrags in Amazon DynamoDB`1`, der `expectedVersion` dem Argument entsprach. Die Anfrage war erfolgreich, was bedeutete, dass das `version` Feld in Amazon DynamoDB auf erhöht wurde. `2`
1. Als Sie die Anfrage zum zweiten Mal ausgeführt haben, war der Wert des `version` Felds des Beitrags in Amazon DynamoDB`2`, der nicht mit dem `expectedVersion` Argument übereinstimmte.
Dieses Muster wird normalerweise als *optimistische Sperre* bezeichnet.
## Stimmenmutationen erstellen (Amazon DynamoDB UpdateItem)
Der `Post` Typ enthält `downs` Felder, um die Aufzeichnung von positiven `ups` und negativen Stimmen zu ermöglichen. Derzeit lässt uns die API jedoch nichts mit ihnen anfangen. Fügen wir eine Mutation hinzu, damit wir die Beiträge positiv und negativ bewerten können.
**Um deine Mutation hinzuzufügen**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Ändern Sie im **Schemabereich** den `Mutation` Typ und fügen Sie die Aufzählung hinzu, `DIRECTION` um neue Stimmenmutationen hinzuzufügen:
```
type Mutation {
vote(id: ID!, direction: DIRECTION!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
id: ID,
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
enum DIRECTION {
UP
DOWN
}
```
1. Wählen Sie **Save Schema (Schema speichern)**.
1. **Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `vote` Feld für den `Mutation` Typ und wählen Sie dann Anhängen aus.** Erstellen Sie einen neuen Resolver, indem Sie den Code erstellen und durch den folgenden Codeausschnitt ersetzen:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const field = ctx.args.direction === 'UP' ? 'ups' : 'downs';
return ddb.update({
key: { id: ctx.args.id },
update: {
[field]: ddb.operations.increment(1),
version: ddb.operations.increment(1),
},
});
}
export const response = (ctx) => ctx.result;
```
1. Speichern Sie alle Änderungen, die Sie vorgenommen haben.
### Rufen Sie die API auf, um einen Beitrag positiv oder negativ zu bewerten
Jetzt, da die neuen Resolver eingerichtet wurden, AWS AppSync weiß, wie man eine eingehende `upvotePost` oder `downvote` Mutation in eine Amazon DynamoDB `UpdateItem` DynamoDB-Operation übersetzt. Sie können jetzt Mutationen ausführen, um Upvotes oder Downvotes für den zuvor erstellten Post auszuführen.
**Um Ihre Mutation auszuführen**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id` Argument auf den Wert aktualisieren, den Sie sich zuvor notiert haben:
```
mutation votePost {
vote(id:123, direction: UP) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann`votePost`.
1. Der aktualisierte Beitrag in Amazon DynamoDB sollte im **Ergebnisbereich** rechts neben dem Bereich **Abfragen angezeigt** werden. Das sollte bei Ihnen ähnlich wie im folgenden Bild aussehen:
```
{
"data": {
"vote": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 0,
"version": 4
}
}
}
```
1. Wählen Sie noch ein paar Mal **Ausführen**. Sie sollten sehen, dass die `version` Felder `ups` und bei `1` jeder Ausführung der Abfrage inkrementiert werden.
1. Ändern Sie die Abfrage, um sie mit einem anderen `DIRECTION` aufzurufen.
```
mutation votePost {
vote(id:123, direction: DOWN) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`votePost`.
Diesmal sollten die `version` Felder `downs` und bei `1` jeder Ausführung der Abfrage inkrementiert werden.
## Einen DeletePost-Resolver einrichten (Amazon DynamoDB) DeleteItem
Als Nächstes möchten Sie eine Mutation erstellen, um einen Beitrag zu löschen. Dazu verwenden Sie den `DeleteItem` Amazon DynamoDB DynamoDB-Vorgang.
**Um Ihre Mutation hinzuzufügen**
1. Wählen Sie in Ihrem Schema die Registerkarte **Schema**.
1. Ändern Sie im **Schemabereich** den `Mutation` Typ, um eine neue `deletePost` Mutation hinzuzufügen:
```
type Mutation {
deletePost(id: ID!, expectedVersion: Int): Post
vote(id: ID!, direction: DIRECTION!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
id: ID
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
1. Dieses Mal haben Sie das `expectedVersion` Feld optional gemacht. Wählen Sie als Nächstes **Schema speichern**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `delete` Feld im `Mutation` Typ und wählen Sie dann **Anhängen** aus. Erstellen Sie mit dem folgenden Code einen neuen Resolver:
```
import { util } from '@aws-appsync/utils'
import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
let condition = null;
if (ctx.args.expectedVersion) {
condition = {
or: [
{ id: { attributeExists: false } },
{ version: { eq: ctx.args.expectedVersion } },
],
};
}
return ddb.remove({ key: { id: ctx.args.id }, condition });
}
export function response(ctx) {
const { error, result } = ctx;
if (error) {
util.appendError(error.message, error.type);
}
return result;
}
```
**Anmerkung**
Das `expectedVersion` Argument ist ein optionales Argument. Wenn der Aufrufer ein `expectedVersion` Argument in der Anfrage festlegt, fügt der Anforderungshandler 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 Amazon DynamoDB genau dem entspricht. `expectedVersion` Wenn es ausgelassen wird, wird kein Bedingungsausdruck für die `DeleteItem`-Anforderung angegeben. Es ist erfolgreich, unabhängig vom Wert von `version` oder ob das Element in Amazon DynamoDB vorhanden ist oder nicht.
Auch wenn Sie einen Artikel löschen, können Sie den gelöschten Artikel zurücksenden, sofern er nicht bereits gelöscht wurde.
Weitere Informationen zu der `DeleteItem` Anfrage finden Sie in der [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)Dokumentation.
### Rufen Sie die API auf, um einen Beitrag zu löschen
Jetzt, da der Resolver eingerichtet wurde, AWS AppSync weiß er, wie eine eingehende `delete` Mutation in eine Amazon DynamoDB `DeleteItem` DynamoDB-Operation übersetzt werden kann. Sie können jetzt eine Mutation ausführen, um Inhalte in der Tabelle zu löschen.
**Um Ihre Mutation auszuführen**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id` Argument auf den Wert aktualisieren, den Sie sich zuvor notiert haben:
```
mutation deletePost {
deletePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann`deletePost`.
1. Der Beitrag wurde aus Amazon DynamoDB gelöscht. Beachten Sie, dass der Wert des Elements AWS AppSync zurückgegeben wird, das aus Amazon 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
}
}
}
```
1. Der Wert wird nur zurückgegeben, wenn dieser Aufruf von derjenige `deletePost` ist, der ihn tatsächlich aus Amazon DynamoDB löscht. **Wählen Sie erneut Ausführen.**
1. Der Aufruf ist immer noch erfolgreich, aber es wird kein Wert zurückgegeben:
```
{
"data": {
"deletePost": null
}
}
```
1. Versuchen wir nun, einen Beitrag zu löschen, aber diesmal geben wir einen an`expectedValue`. Zunächst müssen Sie einen neuen Beitrag erstellen, da Sie gerade den gelöscht haben, mit dem Sie bisher gearbeitet haben.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu:
```
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
}
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend`addPost`.
1. Die Ergebnisse des neu erstellten Beitrags sollten im **Ergebnisbereich** rechts neben dem **Abfragebereich angezeigt** werden. Notieren Sie den Wert `id` des neu erstellten Objekts, da Sie ihn gleich benötigen werden. 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
}
}
}
```
1. Versuchen wir nun, den Beitrag mit einem illegalen Wert für **expectedVersion** zu löschen. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id` Argument auf den Wert aktualisieren, den Sie sich zuvor notiert haben:
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 9999
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann`deletePost`. Das folgende Ergebnis wird zurückgegeben:
```
{
"data": {
"deletePost": null
},
"errors": [
{
"path": [
"deletePost"
],
"data": null,
"errorType": "DynamoDB:ConditionalCheckFailedException",
"errorInfo": null,
"locations": [
{
"line": 2,
"column": 3,
"sourceName": null
}
],
"message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)"
}
]
}
```
1. Die Anforderung ist fehlgeschlagen, da der Bedingungsausdruck zu `false` ausgewertet wird. Der Wert für `version` des Beitrags in Amazon 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
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann. `deletePost`
Diesmal ist die Anfrage erfolgreich und der Wert, der aus Amazon 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
}
}
}
```
1. **Wählen Sie erneut Ausführen.** Der Aufruf ist immer noch erfolgreich, aber diesmal wird kein Wert zurückgegeben, da der Beitrag bereits in Amazon DynamoDB gelöscht wurde.
```
{ "data": { "deletePost": null } }
```
## Einen AllPost-Resolver einrichten (Amazon DynamoDB Scan)
Bisher ist die API nur nützlich, wenn Sie die einzelnen Beiträge kennen, `id` die Sie sich ansehen möchten. Fügen wir jetzt einen neuen Resolver hinzu, der alle Posts in der Tabelle zurückgibt.
**Um deine Mutation hinzuzufügen**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Ändern Sie im Bereich **Schema** den `Query` Typ, um eine neue `allPost` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
1. Fügen Sie einen neuen `PaginationPosts`-Typ hinzu:
```
type PaginatedPosts {
posts: [Post!]!
nextToken: String
}
```
1. Wählen Sie **Save Schema (Schema speichern)**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `allPost` Feld für den `Query` Typ und wählen Sie dann **Anhängen** aus. Erstellen Sie einen neuen Resolver mit dem folgenden Code:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken } = ctx.arguments;
return ddb.scan({ limit, nextToken });
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Der Request-Handler dieses Resolvers erwartet zwei optionale Argumente:
+ `limit`- Gibt die maximale Anzahl von Elementen an, die in einem einzigen Aufruf zurückgegeben werden sollen.
+ `nextToken`- Wird verwendet, um die nächsten Ergebnisse abzurufen (wir werden später zeigen, woher der Wert für `nextToken` stammt).
1. Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
Weitere Informationen zur `Scan` Anfrage finden Sie in der Referenzdokumentation zum [Scannen](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan).
### Rufen Sie die API auf, um alle Beiträge zu scannen
Jetzt, da der Resolver eingerichtet wurde, AWS AppSync weiß er, wie eine eingehende `allPost` Anfrage in einen Amazon DynamoDB `Scan` DynamoDB-Vorgang übersetzt wird. 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.
**Um Daten hinzuzufügen und abzufragen**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu:
```
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 }
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche).
1. Scannen wir jetzt die Tabelle so, dass jeweils fünf Ergebnisse zurückgegeben werden. Fügen Sie im Bereich **Abfragen** die folgende Abfrage hinzu:
```
query allPost {
allPost(limit: 5) {
posts {
id
title
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`allPost`.
Die ersten fünf Beiträge 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": ""
}
}
}
```
1. Sie haben fünf Ergebnisse und ein Ergebnis erhalten`nextToken`, das Sie verwenden können, um die nächsten Ergebnisse zu erhalten. Aktualisieren Sie die `allPost`-Abfrage, um das `nextToken` aus dem vorherigen Ergebnissatz einzuschließen:
```
query allPost {
allPost(
limit: 5
nextToken: ""
) {
posts {
id
author
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Taste) und dann`allPost`.
Die verbleibenden vier Beiträge sollten im **Ergebnisbereich** rechts neben dem **Abfragebereich angezeigt** werden. `nextToken`In dieser Ergebnisgruppe gibt es keine, da Sie alle neun Beiträge durchgeblättert haben und keiner mehr übrig ist. 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
}
}
}
```
## Einen allPostsBy Author-Resolver einrichten (Amazon DynamoDB Query)
Sie können Amazon DynamoDB nicht nur nach allen Beiträgen durchsuchen, sondern auch Amazon DynamoDB abfragen, um Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden. Die Amazon DynamoDB-Tabelle, die Sie zuvor erstellt haben, hat bereits einen `GlobalSecondaryIndex` Aufruf`author-index`, den Sie mit einer Amazon DynamoDB `Query` DynamoDB-Operation verwenden können, um alle Beiträge abzurufen, die von einem bestimmten Autor erstellt wurden.
**Um Ihre Abfrage hinzuzufügen**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Ändern Sie im Bereich **Schema** den `Query` Typ, um eine neue `allPostsByAuthor` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
Beachten Sie, dass dabei derselbe `PaginatedPosts` Typ verwendet wird, den Sie für die `allPost` Abfrage verwendet haben.
1. Wählen Sie **Save Schema (Schema speichern)**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `allPostsByAuthor` Feld für den `Query` Typ, und wählen Sie dann **Anhängen** aus. Erstellen Sie mit dem folgenden Codeausschnitt einen Resolver:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken, author } = ctx.arguments;
return ddb.query({
index: 'author-index',
query: { author: { eq: author } },
limit,
nextToken,
});
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Wie der `allPost` Resolver hat auch dieser Resolver zwei optionale Argumente:
+ `limit`- Gibt die maximale Anzahl von Elementen an, die in einem einzigen Aufruf zurückgegeben werden sollen.
+ `nextToken`- Ruft den nächsten Satz von Ergebnissen ab (der Wert für `nextToken` kann aus einem vorherigen Aufruf abgerufen werden).
1. Speichert alle an Ihrem Resolver vorgenommenen Änderungen.
Weitere Informationen zu der `Query` Anfrage finden Sie in der [Query-Referenzdokumentation](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-query).
### Rufen Sie die API auf, um alle Beiträge nach Autor abzufragen
Jetzt, da der Resolver eingerichtet wurde, AWS AppSync weiß er, wie man eine eingehende `allPostsByAuthor` Mutation in eine `Query` DynamoDB-Operation anhand des Index übersetzt. `author-index` Sie können nun die Tabelle abfragen, um alle Posts von einem bestimmten Autor abzurufen.
Vorher sollten wir die Tabelle jedoch mit einigen weiteren Beiträgen füllen, da bisher alle Beiträge denselben Autor haben.
**Um Daten hinzuzufügen und abzufragen**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu:
```
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 }
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend`addPost`.
1. Wir fragen jetzt die Tabelle ab, so dass alle Posts von `Nadia` zurückgegeben werden. Fügen Sie im Bereich **Abfragen** die folgende Abfrage hinzu:
```
query allPostsByAuthor {
allPostsByAuthor(author: "Nadia") {
posts {
id
title
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`allPostsByAuthor`. Alle Beiträge, die von verfasst wurden, `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
}
}
}
```
1. 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.
1. Fügen Sie im Bereich **Abfragen** die folgende Abfrage hinzu:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
limit: 5
) {
posts {
id
title
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`allPostsByAuthor`. Alle Beiträge, die von verfasst wurden, `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": ""
}
}
}
```
1. Aktualisieren Sie das `nextToken`-Argument mit dem Wert, der in der vorherigen Abfrage zurückgegeben wurde:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
limit: 5
nextToken: ""
) {
posts {
id
title
}
nextToken
}
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend. `allPostsByAuthor` Die verbleibenden Beiträge, die von verfasst wurden, `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 Sets
Bis zu diesem Zeitpunkt war der `Post` Typ ein flaches key/value Objekt. Sie können mit Ihrem 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 null 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.
**Um Ihre Daten einzurichten**
1. Wählen Sie in Ihrer API den Tab **Schema**.
1. Ändern Sie im Bereich **Schema** 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!]
}
```
1. Ändern Sie im **Schemabereich** den `Query` Typ, um eine neue `allPostsByTag` Abfrage hinzuzufügen, wie folgt:
```
type Query {
allPostsByTag(tag: String!, limit: Int, nextToken: String): PaginatedPosts!
allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
1. Ä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!
}
```
1. Wählen Sie **Save Schema (Schema speichern)**.
1. Suchen Sie im Bereich **Resolver** auf der rechten Seite nach dem neu erstellten `allPostsByTag` Feld für den `Query` Typ und wählen Sie dann **Anhängen** aus. Erstellen Sie Ihren Resolver mithilfe des folgenden Snippets:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken, tag } = ctx.arguments;
return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } });
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
1. Speichern Sie alle Änderungen, die Sie an Ihrem Resolver vorgenommen haben.
1. Gehen Sie nun `addTag` mit dem folgenden Codeausschnitt genauso für das `Mutation` Feld vor:
**Anmerkung**
Obwohl die DynamoDB-Utils derzeit keine Mengenoperationen unterstützen, können Sie trotzdem mit Sets interagieren, indem Sie die Anfrage selbst erstellen.
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
const { id, tag } = ctx.arguments
const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 })
expressionValues[':tags'] = util.dynamodb.toStringSet([tag])
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: `ADD tags :tags, version :plusOne`,
expressionValues,
},
}
}
export const response = (ctx) => ctx.result
```
1. Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
1. Wiederholen Sie dies noch einmal für das `Mutation` Feld `removeTag` mit dem folgenden Codeausschnitt:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, tag } = ctx.arguments;
const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 });
expressionValues[':tags'] = util.dynamodb.toStringSet([tag]);
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: `DELETE tags :tags ADD version :plusOne`,
expressionValues,
},
};
}
export const response = (ctx) => ctx.resultexport
```
1. Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
### 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.
**Um Tags zu verwenden**
1. Wählen Sie in Ihrer API den Tab **Abfragen** aus.
1. Fügen Sie im Bereich **Abfragen** die folgende Abfrage hinzu:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "Nadia"
) {
posts {
id
title
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`allPostsByAuthor`.
1. Alle Beiträge 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
}
}
}
```
1. Verwenden wir den mit dem Titel *Der süßeste Hund der Welt*. Nimm es auf`id`, weil du es später benutzen wirst. Versuchen wir nun, ein `dog` Tag hinzuzufügen.
1. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id`-Argument mit dem zuvor notierten Wert aktualisieren.
```
mutation addTag {
addTag(id:10 tag: "dog") {
id
title
tags
}
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend`addTag`. Der Beitrag wurde mit dem neuen Tag aktualisiert:
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
1. Sie können weitere Tags hinzufügen. Aktualisieren Sie die Mutation, um das `tag` Argument wie folgt zu ändern`puppy`:
```
mutation addTag {
addTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
1. Wählen Sie „**Ausführen**“ (die orangefarbene Play-Schaltfläche) und anschließend`addTag`. Der Beitrag wurde mit dem neuen Tag aktualisiert:
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
}
}
```
1. Sie können Tags auch löschen. Fügen Sie im Bereich **Abfragen** die folgende Mutation hinzu. Außerdem müssen Sie das `id` Argument auf den Wert aktualisieren, den Sie sich zuvor notiert haben:
```
mutation removeTag {
removeTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und dann`removeTag`. Der Post wird aktualisiert und das Tag `puppy` wird gelöscht.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
1. Du kannst auch nach allen Beiträgen suchen, die ein Schlagwort haben. Fügen Sie im Bereich **Abfragen** die folgende Abfrage hinzu:
```
query allPostsByTag {
allPostsByTag(tag: "dog") {
posts {
id
title
tags
}
nextToken
}
}
```
1. Wählen Sie **Ausführen** (die orangefarbene Play-Schaltfläche) und anschließend`allPostsByTag`. 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
}
}
}
```
## Schlussfolgerung
In diesem Tutorial haben Sie eine API erstellt, mit der Sie `Post` Objekte in DynamoDB mithilfe AWS AppSync von GraphQL bearbeiten können.
Zum Aufräumen können Sie die AWS AppSync GraphQL-API von der Konsole löschen.
**Um die mit Ihrer DynamoDB-Tabelle verknüpfte Rolle zu löschen, wählen Sie Ihre Datenquelle in der Tabelle **Datenquellen** aus und klicken Sie auf Bearbeiten.** Notieren Sie sich den Wert der Rolle unter **Eine bestehende Rolle erstellen oder verwenden**. Gehen Sie zur IAM-Konsole, um die Rolle zu löschen.
Um Ihre DynamoDB-Tabelle zu löschen, klicken Sie in der Datenquellenliste auf den Namen der Tabelle. Dadurch gelangen Sie zur DynamoDB-Konsole, in der Sie die Tabelle löschen können.