Erstellen einer einfachen Post-Anwendung mit DynamoDB-Resolvern JavaScript - AWS AppSync

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

  1. Öffnen Sie die AppSync Konsole und wählen Sie Create API.

  2. Wählen Sie „Von Grund auf neu entwerfen“ und dann „Weiter“.

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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. 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! }
  3. 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

  1. Wählen Sie auf der Schemaseite Create Resources aus.

  2. Wählen Sie Bestehenden Typ verwenden und wählen Sie dann den Post Typ aus.

  3. Wählen Sie im Abschnitt Zusätzliche Indizes die Option Index hinzufügen aus.

  4. Benennen Sie den Indexauthor-index.

  5. Stellen Sie Primary key das Auf author und den Sort Schlüssel auf einNone.

  6. Deaktivieren Sie GraphQL automatisch generieren. In diesem Beispiel erstellen wir den Resolver selbst.

  7. 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 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 Ihrem API die Registerkarte Schema.

  2. Suchen Sie im Bereich Resolver das addPost Feld unter dem Mutation Typ und wählen Sie dann Anhängen aus.

  3. Wählen Sie Ihre Datenquelle und dann Erstellen aus.

  4. 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 }
  5. 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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendaddPost. 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.

  2. 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/' } } }
  3. AWS AppSync verwendet diesen Wert, um eine Amazon DynamoDB PutItem DynamoDB-Anfrage zu generieren und auszuführen.

  4. 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 }
  5. Der Antworthandler gibt das Ergebnis sofort zurück (return ctx.result).

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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Suchen Sie im Bereich Resolver auf der rechten Seite das getPost Feld für den Query Typ und wählen Sie dann Anhängen aus.

  3. Wählen Sie Ihre Datenquelle und dann Erstellen aus.

  4. 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
  5. 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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und danngetPost. Die Ergebnisse des neu erstellten Beitrags sollten im Ergebnisbereich rechts neben dem Abfragebereich angezeigt werden.

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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Ä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! }
  3. Wählen Sie Save Schema (Schema speichern).

  4. 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 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;
  5. 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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“updatePost.

  4. 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 DynamoDB1, der expectedVersion dem Argument entsprach. Die Anfrage war erfolgreich, was bedeutete, dass das version Feld in Amazon DynamoDB auf erhöht wurde. 2

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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Ä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 }
  3. Wählen Sie Save Schema (Schema speichern).

  4. 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;
  5. 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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“votePost.

  4. 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 } } }
  5. 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.

  6. Ä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 } }
  7. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und wählen Sie dannvotePost.

    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.

  2. Ä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! }
  3. Dieses Mal haben Sie das expectedVersion Feld optional gemacht. Wählen Sie als Nächstes Schema speichern.

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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“deletePost.

  4. 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 } } }
  5. 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.

  6. Der Aufruf ist immer noch erfolgreich, aber es wird kein Wert zurückgegeben:

    { "data": { "deletePost": null } }
  7. Versuchen wir nun, einen Beitrag zu löschen, aber diesmal geben wir einen anexpectedValue. Zunächst müssen Sie einen neuen Beitrag erstellen, da Sie gerade den gelöscht haben, mit dem Sie bisher gearbeitet haben.

  8. 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 } }
  9. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendaddPost.

  10. 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 } } }
  11. 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 } }
  12. 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)" } ] }
  13. 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 } }
  14. 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 } } }
  15. 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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Ä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 }
  3. Fügen Sie einen neuen PaginationPosts-Typ hinzu:

    type PaginatedPosts { posts: [Post!]! nextToken: String }
  4. Wählen Sie Save Schema (Schema speichern).

  5. 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).

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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen aus.

  2. 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 } }
  3. Wählen Sie Ausführen (die orangefarbene Play-Schaltfläche).

  4. 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 } }
  5. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendallPost.

    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>" } } }
  6. Sie haben fünf Ergebnisse und ein Ergebnis erhaltennextToken, 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: "<token>" ) { posts { id author } nextToken } }
  7. 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. nextTokenIn 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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Ä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.

  3. Wählen Sie Save Schema (Schema speichern).

  4. 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).

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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. 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 } }
  3. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendaddPost.

  4. 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 } }
  5. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendallPostsByAuthor. 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 } } }
  6. 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.

  7. Fügen Sie im Bereich Abfragen die folgende Abfrage hinzu:

    query allPostsByAuthor { allPostsByAuthor( author: "AUTHORNAME" limit: 5 ) { posts { id title } nextToken } }
  8. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendallPostsByAuthor. 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>" } } }
  9. 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 } }
  10. 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

  1. Wählen Sie in Ihrem API die Registerkarte Schema.

  2. Ä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!] }
  3. Ä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 }
  4. Ä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! }
  5. Wählen Sie Save Schema (Schema speichern).

  6. 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 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 }; }
  7. Speichern Sie alle Änderungen, die Sie an Ihrem Resolver vorgenommen haben.

  8. 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
  9. Speichern Sie alle an Ihrem Resolver vorgenommenen Änderungen.

  10. 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
  11. 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

  1. Wählen Sie in Ihrem API die Registerkarte Abfragen.

  2. Fügen Sie im Bereich Abfragen die folgende Abfrage hinzu:

    query allPostsByAuthor { allPostsByAuthor( author: "Nadia" ) { posts { id title } nextToken } }
  3. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendallPostsByAuthor.

  4. 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 } } }
  5. Verwenden wir den mit dem Titel Der süßeste Hund der Welt. Nimm es aufid, weil du es später benutzen wirst. Versuchen wir nun, ein dog Tag hinzuzufügen.

  6. 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 } }
  7. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendaddTag. Der Beitrag wurde mit dem neuen Tag aktualisiert:

    { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog" ] } } }
  8. 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 } }
  9. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendaddTag. Der Beitrag wurde mit dem neuen Tag aktualisiert:

    { "data": { "addTag": { "id": "10", "title": "The cutest dog in the world", "tags": [ "dog", "puppy" ] } } }
  10. 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 } }
  11. Wähle „Ausführen“ (die orangefarbene Play-Schaltfläche) und dann „Ausführen“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" ] } } }
  12. 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 } }
  13. Wählen Sie „Ausführen“ (die orangefarbene Play-Schaltfläche) und anschließendallPostsByTag. 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 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.