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 API mithilfe von JavaScript Pipeline-Resolvern, die Sie in Ihrer eigenen Anwendung nutzen können, ein voll funktionsfähiges GraphQL 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 Ihr GraphQL API
Um ein GraphQL API zu erstellen in AWS AppSync
-
Öffnen Sie die AppSync Konsole und wählen Sie Create API.
-
Wählen Sie „Von Grund auf neu entwerfen“ und dann „Weiter“.
-
Geben Sie Ihrem API
PostTutorialAPI
Namen 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 SieCreate
.
Die AWS AppSync Konsole erstellt ein neues GraphQL API für Sie. Standardmäßig wird der API Schlüsselauthentifizierungsmodus verwendet. Sie können die Konsole verwenden, um den Rest von GraphQL einzurichten API und für den Rest dieses Tutorials Abfragen darauf auszuführen.
Definieren Sie einen einfachen Beitrag API
Jetzt, wo Sie Ihr GraphQL habenAPI, 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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Wir werden ein Schema erstellen, das einen
Post
Typ und eine OperationaddPost
zum Hinzufügen und Abrufen vonPost
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! }
-
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 ein, den wir später verwenden werden.
So erstellen Sie Ihre Amazon DynamoDB-Tabelle
-
Wählen Sie auf der Schemaseite Create Resources aus.
-
Wählen Sie Bestehenden Typ verwenden und wählen Sie dann den
Post
Typ aus. -
Wählen Sie im Abschnitt Zusätzliche Indizes die Option Index hinzufügen aus.
-
Benennen Sie den Index
author-index
. -
Stellen Sie
Primary key
das Aufauthor
und denSort
Schlüssel auf einNone
. -
Deaktivieren Sie GraphQL automatisch generieren. In diesem Beispiel erstellen wir den Resolver selbst.
-
Wählen Sie Create (Erstellen) aus.
Sie haben jetzt eine neue Datenquelle namensPostTable
, 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 TypMutation
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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Suchen Sie im Bereich Resolver das
addPost
Feld unter demMutation
Typ und wählen Sie dann Anhängen aus. -
Wählen Sie Ihre Datenquelle und dann Erstellen aus.
-
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 }
-
Wählen Sie Save (Speichern) aus.
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 namensutil.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 finden Sie unter JavaScriptLaufzeitfunktionen für Resolver und Funktionen. JavaScript
Rufen Sie die API an, 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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
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:
-
AWS AppSync hat eine
addPost
Mutationsanfrage erhalten. -
AWS AppSync führt den Request-Handler des Resolvers aus. Die
ddb.put
Funktion erstellt einePutItem
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/' } } }
-
AWS AppSync verwendet diesen Wert, um eine Amazon DynamoDB
PutItem
DynamoDB-Anfrage 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 }
-
Der Antworthandler gibt das Ergebnis sofort zurück (
return ctx.result
). -
Das Endergebnis ist in der GraphQL-Antwort sichtbar.
Den getPost Resolver einrichten (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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Suchen Sie im Bereich Resolver auf der rechten Seite das
getPost
Feld für denQuery
Typ und wählen Sie dann Anhängen aus. -
Wählen Sie Ihre Datenquelle und dann Erstellen aus.
-
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
-
Speichern Sie Ihren Resolver.
Anmerkung
In diesem Resolver verwenden wir einen Pfeilfunktionsausdruck für den Antworthandler.
Ruf die anAPI, um einen Beitrag zu bekommen
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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
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. -
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 dasid
, und benötigtauthor
, können Sie Ihre Anforderungsfunktion 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 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 selectionSetListmit verwendengetPost
, 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 UpdateItem
Amazon DynamoDB operation.sc
Um Ihren Resolver zu aktualisieren
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Ändern Sie im Schemabereich den
Mutation
Typ, um eine neueupdatePost
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! }
-
Wählen Sie Save Schema (Schema speichern).
-
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
updatePost
Feld für denMutation
Typ und wählen Sie dann Anhängen aus. Erstellen Sie Ihren neuen Resolver mit dem folgenden Codeausschnitt: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;
-
Speichern Sie alle Änderungen, die Sie vorgenommen haben.
Dieser Resolver wird verwendetddb.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 istnull
, 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.
Weitere Informationen zu der UpdateItem
Anfrage finden Sie in der UpdateItemDokumentation und in der Dokumentation zum DynamoDB-Modul.
Weitere Informationen zum Schreiben von Aktualisierungsausdrücken finden Sie in der DynamoDB-Dokumentation UpdateExpressions.
Rufen Sie den aufAPI, um einen Beitrag zu aktualisieren
Versuchen wir, das Post
Objekt mit dem neuen Resolver zu aktualisieren.
Um dein Objekt zu aktualisieren
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
updatePost
. -
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
-
Als Sie die Anfrage zum ersten Mal ausgeführt haben, war der Wert des
version
Felds des Beitrags in Amazon DynamoDB1
, derexpectedVersion
dem Argument entsprach. Die Anfrage war erfolgreich, was bedeutete, dass dasversion
Feld in Amazon DynamoDB auf erhöht wurde.2
-
Als Sie die Anfrage zum zweiten Mal ausgeführt haben, war der Wert des
version
Felds des Beitrags in Amazon DynamoDB2
, der nicht mit demexpectedVersion
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. Im Moment erlaubt uns das API jedoch nichts mit ihnen zu machen. Fügen wir eine Mutation hinzu, damit wir die Beiträge positiv und negativ bewerten können.
Um deine Mutation hinzuzufügen
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Ä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 }
-
Wählen Sie Save Schema (Schema speichern).
-
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
vote
Feld für denMutation
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;
-
Speichern Sie alle Änderungen, die Sie vorgenommen haben.
Rufen Sie die API an, um einen Beitrag positiv oder negativ zu bewerten
Jetzt, da die neuen Resolver eingerichtet wurden, AWS AppSync weiß, wie man einen eingehenden Vorgang upvotePost
oder eine downvote
Mutation in einen Amazon DynamoDB DynamoDB-Vorgang UpdateItem
ü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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
votePost
. -
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 } } }
-
Wählen Sie noch ein paar Mal Ausführen. Sie sollten sehen, dass die
version
Felderups
und bei1
jeder Ausführung der Abfrage inkrementiert werden. -
Ändern Sie die Abfrage so, dass sie mit einer anderen
DIRECTION
aufgerufen wird.mutation votePost { vote(id:123, direction: DOWN) { id author title content url ups downs version } }
-
Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und wählen Sie dann
votePost
.Diesmal sollten die
version
Felderdowns
und bei1
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
-
Wählen Sie in Ihrem Schema die Registerkarte Schema.
-
Ändern Sie im Schemabereich den
Mutation
Typ, um eine neuedeletePost
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! }
-
Dieses Mal haben Sie das
expectedVersion
Feld optional gemacht. Wählen Sie als Nächstes Schema speichern. -
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
delete
Feld imMutation
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 einexpectedVersion
Argument in der Anfrage festlegt, fügt der Anforderungshandler eine Bedingung hinzu, die nur dann den Erfolg derDeleteItem
Anfrage ermöglicht, wenn das Element bereits gelöscht wurde oder wenn dasversion
Attribut des Beitrags in Amazon DynamoDB genau dem entspricht.expectedVersion
Wenn es ausgelassen wird, wird kein Bedingungsausdruck für dieDeleteItem
-Anforderung angegeben. Es ist erfolgreich, unabhängig vom Wert vonversion
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 DeleteItemDokumentation.
Rufen Sie die API an, 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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
deletePost
. -
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 } } }
-
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. -
Der Aufruf ist immer noch erfolgreich, aber es wird kein Wert zurückgegeben:
{ "data": { "deletePost": null } }
-
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. -
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 } }
-
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. 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 } } }
-
Versuchen wir nun, den Beitrag mit einem unzulässigen Wert für zu löschen expectedVersion. 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 } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
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)" } ] }
-
Die Anforderung ist fehlgeschlagen, da der Bedingungsausdruck zu
false
ausgewertet wird. Der Wert fürversion
des Beitrags in Amazon DynamoDB entspricht nicht dem in den ArgumentenexpectedValue
angegebenen Wert. Der aktuelle Wert des Objekts wird im Felddata
im Abschnitterrors
der GraphQL-Antwort zurückgegeben. Wiederholen Sie die Anforderung und korrigieren Sie dabeiexpectedVersion
:mutation deletePost { deletePost( id:123 expectedVersion: 1 ) { id author title content url ups downs version } }
-
Wählen Sie Ausführen (die orangefarbene Play-Schaltfläche) und wählen Sie 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 } } }
-
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 API ist das 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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Ändern Sie im Bereich Schema den
Query
Typ, um eine neueallPost
Abfrage hinzuzufügen, wie folgt:type Query { allPost(limit: 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 Save Schema (Schema speichern).
-
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
allPost
Feld für denQuery
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ürnextToken
stammt).
-
-
Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
Weitere Informationen zur Scan
Anfrage finden Sie in der Referenzdokumentation zum Scannen.
Rufen Sie den API an, 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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen aus.
-
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 } }
-
Wählen Sie Ausführen (die orangefarbene Play-Schaltfläche).
-
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 } }
-
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": "<token>" } } }
-
Sie haben fünf Ergebnisse und ein Ergebnis erhalten
nextToken
, das Sie verwenden können, um die nächsten Ergebnisse zu erhalten. Aktualisieren Sie dieallPost
-Abfrage, um dasnextToken
aus dem vorherigen Ergebnissatz einzuschließen:query allPost { allPost( limit: 5 nextToken: "<token>" ) { posts { id author } nextToken } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
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
Aufrufauthor-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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Ändern Sie im Bereich Schema den
Query
Typ, um eine neueallPostsByAuthor
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 dieallPost
Abfrage verwendet haben. -
Wählen Sie Save Schema (Schema speichern).
-
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
allPostsByAuthor
Feld für denQuery
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ürnextToken
kann aus einem vorherigen Aufruf abgerufen werden).
-
-
Speichert alle an Ihrem Resolver vorgenommenen Änderungen.
Weitere Informationen zu der Query
Anfrage finden Sie in der Query-Referenzdokumentation.
Rufen Sie den 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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
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 } }
-
Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließend
addPost
. -
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 } }
-
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 } } }
-
Die Paginierung funktioniert für
Query
genauso wie fürScan
. Suchen wir z. B. nach allen Posts vonAUTHORNAME
, wobei jeweils fünf Posts abgerufen werden. -
Fügen Sie im Bereich Abfragen die folgende Abfrage hinzu:
query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" limit: 5 ) { posts { id title } nextToken } }
-
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": "<token>" } } }
-
Aktualisieren Sie das
nextToken
-Argument mit dem Wert, der in der vorherigen Abfrage zurückgegeben wurde:query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" limit: 5 nextToken: "<token>" ) { posts { id title } nextToken } }
-
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 Sätzen
Bis zu diesem Zeitpunkt war der Post
Typ ein flaches Schlüssel/Wert-Objekt. Sie können mit Ihrem Resolver auch komplexe Objekte wie Sets, 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
-
Wählen Sie in Ihrem API die Registerkarte Schema.
-
Ändern Sie im Bereich Schema den
Post
Typ wie folgt, um ein neuestags
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 neueallPostsByTag
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 }
-
Ändern Sie im Schemabereich den
Mutation
Typ, um neueaddTag
undremoveTag
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 Save Schema (Schema speichern).
-
Suchen Sie im Bereich Resolver auf der rechten Seite nach dem neu erstellten
allPostsByTag
Feld für denQuery
Typ und wählen Sie dann Anhängen aus. Erstellen Sie Ihren Resolver mit dem folgenden Codeausschnitt: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 }; }
-
Speichern Sie alle Änderungen, die Sie an Ihrem Resolver vorgenommen haben.
-
Gehen Sie nun
addTag
mit dem folgenden Codeausschnitt genauso für dasMutation
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
-
Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
-
Wiederholen Sie dies noch einmal für das
Mutation
FeldremoveTag
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
-
Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.
Rufen Sie den anAPI, um mit Tags zu arbeiten
Jetzt, wo 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
-
Wählen Sie in Ihrem API die Registerkarte Abfragen.
-
Fügen Sie im Bereich Abfragen die folgende Abfrage hinzu:
query allPostsByAuthor { allPostsByAuthor( author: "Nadia" ) { posts { id title } nextToken } }
-
Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließend
allPostsByAuthor
. -
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 } } }
-
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, eindog
Tag hinzuzufügen. -
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 } }
-
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" ] } } }
-
Sie können weitere Tags hinzufügen. Aktualisieren Sie die Mutation, um das
tag
Argument wie folgt zu ändernpuppy
:mutation addTag { addTag(id:10 tag: "puppy") { id title tags } }
-
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" ] } } }
-
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 } }
-
Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“
removeTag
. Der Post wird aktualisiert und das Tagpuppy
wird gelöscht.{ "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } }
-
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 } }
-
Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließend
allPostsByTag
. Alle Posts mit dem Tagdog
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 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.