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.
# AWS AppSync JavaScript Übersicht über Resolver
AWS AppSync ermöglicht es Ihnen, auf GraphQL-Anfragen zu antworten, indem Sie Operationen an Ihren Datenquellen ausführen. Für jedes GraphQL-Feld, für das Sie eine Abfrage, Mutation oder ein Abonnement ausführen möchten, muss ein Resolver angehängt werden.
Resolver sind die Verbindungen zwischen GraphQL und einer Datenquelle. Sie erklären, AWS AppSync wie Sie eine eingehende GraphQL-Anfrage in Anweisungen für Ihre Backend-Datenquelle übersetzen und wie Sie die Antwort von dieser Datenquelle zurück in eine GraphQL-Antwort übersetzen. Mit AWS AppSync können Sie Ihre Resolver in der () -Umgebung schreiben JavaScript und ausführen. AWS AppSync `APPSYNC_JS`
AWS AppSync ermöglicht es Ihnen, Unit-Resolver oder Pipeline-Resolver zu schreiben, die aus mehreren AWS AppSync Funktionen in einer Pipeline bestehen.
## Unterstützte Laufzeitfunktionen
Die AWS AppSync JavaScript Runtime bietet eine Teilmenge von JavaScript Bibliotheken, Dienstprogrammen und Funktionen. Eine vollständige Liste der Features und Funktionen, die von der Runtime unterstützt werden, finden Sie unter `APPSYNC_JS` [JavaScript Runtime-Features für Resolver und](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) Funktionen.
## Resolver für Einheiten
Ein Unit-Resolver besteht aus Code, der einen Anforderungs- und Antworthandler definiert, die für eine Datenquelle ausgeführt werden. Der Anforderungshandler verwendet ein Kontextobjekt als Argument und gibt die Anforderungsnutzdaten zurück, die zum Aufrufen Ihrer Datenquelle verwendet wurden. Der Antworthandler erhält von der Datenquelle eine Nutzlast mit dem Ergebnis der ausgeführten Anfrage zurück. Der Response-Handler wandelt die Nutzlast in eine GraphQL-Antwort um, um das GraphQL-Feld aufzulösen. Im folgenden Beispiel ruft ein Resolver ein Element aus einer DynamoDB-Datenquelle ab:
```
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;
```
## Aufbau eines Pipeline-Resolvers JavaScript
Ein Pipeline-Resolver besteht aus Code, der einen Anfrage- und Antworthandler sowie eine Liste von Funktionen definiert. Jede Funktion hat einen **Anforderungs** - und **Antworthandler**, den sie für eine Datenquelle ausführt. Da ein Pipeline-Resolver Läufe an eine Liste von Funktionen delegiert, ist er daher mit keiner Datenquelle verknüpft. Unit-Resolver und -Funktionen sind Primitive, die Operation auf Datenquellen auszuführen.
### Anforderungshandler für Pipeline-Resolver
Der Anforderungshandler eines Pipeline-Resolvers (der vorherige Schritt) ermöglicht es Ihnen, einige Vorbereitungslogik durchzuführen, bevor Sie die definierten Funktionen ausführen.
### Funktionsliste
Die Liste der Funktionen eines Pipeline-Resolvers wird nacheinander ausgeführt. Das Ergebnis der Auswertung des Pipeline-Resolver-Request-Handlers wird der ersten Funktion als zur Verfügung gestellt. `ctx.prev.result` Jedes Ergebnis der Funktionsauswertung steht der nächsten Funktion als `ctx.prev.result` zur Verfügung.
### Antworthandler für den Pipeline-Resolver
Der Response-Handler eines Pipeline-Resolvers ermöglicht es Ihnen, einige letzte Logik von der Ausgabe der letzten Funktion bis zum erwarteten GraphQL-Feldtyp auszuführen. Die Ausgabe der letzten Funktion in der Funktionsliste ist im Response-Handler des Pipeline-Resolvers als oder verfügbar. `ctx.prev.result` `ctx.result`
### Ablauf der Ausführung
Bei einem Pipeline-Resolver, der aus zwei Funktionen besteht, stellt die folgende Liste den Ausführungsablauf dar, wenn der Resolver aufgerufen wird:
1. Anforderungshandler für Pipeline-Resolver
1. Funktion 1: Funktionsanforderungshandler
1. Funktion 1: Aufruf der Datenquelle
1. Funktion 1: Funktionsantwort-Handler
1. Funktion 2: Funktionsanforderungshandler
1. Funktion 2: Aufruf der Datenquelle
1. Funktion 2: Funktionsantwort-Handler
1. Antworthandler für den Pipeline-Resolver
![\[GraphQL request flow diagram showing interactions between request, data sources, and response components.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/appsync-js-resolver-logic.png)
### Nützliche integrierte `APPSYNC_JS` Runtime-Dienstprogramme
Die folgenden Dienstprogramme unterstützen die Arbeit mit Pipeline-Resolvern.
#### ctx.stash
Der Stash ist ein Objekt, das in jedem Resolver und jedem Funktionsanforderungs- und Antworthandler zur Verfügung gestellt wird. Dieselbe Stash-Instanz durchläuft einen einzigen Resolver-Lauf. Das bedeutet, dass Sie den Stash verwenden können, um beliebige Daten zwischen Anfrage- und Antworthandlern und zwischen Funktionen in einem Pipeline-Resolver zu übergeben. Sie können den Stash wie ein normales Objekt testen. JavaScript
#### ctx.prev.result
`ctx.prev.result` ist das Ergebnis der vorherigen Operation, die in der Pipeline ausgeführt wurde. Wenn es sich bei der vorherigen Operation um den Anforderungshandler für den Pipeline-Resolver handelte, `ctx.prev.result` wird er der ersten Funktion in der Kette zur Verfügung gestellt. Wenn die vorherige Operation die erste Funktion betraf, steht `ctx.prev.result` für die Ausgabe der ersten Funktion und wird der zweiten Funktion in der Pipeline zur Verfügung gestellt. Wenn die vorherige Operation die letzte Funktion war, stellt sie die Ausgabe der letzten Funktion `ctx.prev.result` dar und wird dem Response-Handler des Pipeline-Resolvers zur Verfügung gestellt.
#### util.error
Das Dienstprogramm `util.error` ist nützlich, um ein Feldfehler auszulösen. Die Verwendung `util.error` innerhalb eines Funktionsanforderungs- oder Antworthandlers löst sofort einen Feldfehler aus, der verhindert, dass nachfolgende Funktionen ausgeführt werden. Weitere Informationen und andere `util.error` Signaturen finden Sie unter [JavaScriptLaufzeitfunktionen für Resolver und](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) Funktionen.
#### util.AppendError
`util.appendError`ist ähnlich wie`util.error()`, mit dem großen Unterschied, dass es die Auswertung des Handlers nicht unterbricht. Stattdessen signalisiert es, dass ein Fehler mit dem Feld aufgetreten ist, ermöglicht aber die Auswertung des Handlers und damit die Rückgabe von Daten. Die Verwendung von `util.appendError` in einer Funktion hat keine Auswirkungen auf die Ausführung des Pipeline-Ablaufs. Weitere Informationen und andere `util.error` Signaturen finden Sie in den [JavaScript Laufzeitfunktionen für Resolver und Funktionen](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
#### Runtime.EarlyReturn
Mit dieser `runtime.earlyReturn` Funktion können Sie von jeder Anforderungsfunktion vorzeitig zurückkehren. Wenn Sie den Request-Handler `runtime.earlyReturn` innerhalb eines Resolvers verwenden, wird er vom Resolver zurückgegeben. Wenn Sie ihn von einem AWS AppSync Funktionsanforderungshandler aus aufrufen, kehren Sie von der Funktion zurück und setzen die Ausführung entweder mit der nächsten Funktion in der Pipeline oder dem Resolver-Response-Handler fort.
### Pipeline-Resolver schreiben
Ein Pipeline-Resolver hat außerdem einen Request- und einen Response-Handler, der die Ausführung der Funktionen in der Pipeline umgibt: Sein Request-Handler wird vor der Anfrage der ersten Funktion ausgeführt, und sein Response-Handler wird nach der Antwort der letzten Funktion ausgeführt. Der Resolver-Anforderungshandler kann Daten so einrichten, dass sie von Funktionen in der Pipeline verwendet werden. Der Resolver-Response-Handler ist für die Rückgabe von Daten verantwortlich, die dem GraphQL-Feldausgabetyp zugeordnet sind. Im folgenden Beispiel definiert ein Resolver-Request-Handler`allowedGroups`; die zurückgegebenen Daten sollten zu einer dieser Gruppen gehören. Dieser Wert kann von den Funktionen des Resolvers verwendet werden, um Daten anzufordern. Der Response-Handler des Resolvers führt eine letzte Prüfung durch und filtert das Ergebnis, um sicherzustellen, dass nur Elemente zurückgegeben werden, die zu den zulässigen Gruppen gehören.
```
import { util } from '@aws-appsync/utils';
/**
* Called before the request function of the first AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
ctx.stash.allowedGroups = ['admin'];
ctx.stash.startedAt = util.time.nowISO8601();
return {};
}
/**
* Called after the response function of the last AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const result = [];
for (const item of ctx.prev.result) {
if (ctx.stash.allowedGroups.indexOf(item.group) > -1) result.push(item);
}
return result;
}
```
#### Funktionen schreiben AWS AppSync
AWS AppSync Funktionen ermöglichen es Ihnen, allgemeine Logik zu schreiben, die Sie für mehrere Resolver in Ihrem Schema wiederverwenden können. Sie können beispielsweise eine AWS AppSync Funktion aufrufen, die für `QUERY_ITEMS` die Abfrage von Elementen aus einer Amazon DynamoDB DynamoDB-Datenquelle zuständig ist. Für Resolver, mit denen Sie Elemente abfragen möchten, fügen Sie die Funktion einfach zur Pipeline des Resolvers hinzu und geben Sie den zu verwendenden Abfrageindex an. Die Logik muss nicht erneut implementiert werden.
## Zusätzliche Themen
**Topics**
+ [Beispiel für einen Pipeline-Resolver mit Amazon DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/writing-code.html)
+ [Konfiguration von Dienstprogrammen für die Laufzeit `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/utility-resolvers.html)
+ [Bündelung TypeScript und Quellzuordnungen für die Runtime `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/additional-utilities.html)
+ [Testen Sie Ihren Resolver und Ihre Funktionshandler](https://docs.aws.amazon.com/appsync/latest/devguide/test-resolvers.html)
+ [Migration von VTL zu JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/migrating-resolvers.html)
+ [Wahl zwischen direktem Datenquellenzugriff und Proxying über eine Lambda-Datenquelle](https://docs.aws.amazon.com/appsync/latest/devguide/choosing-data-source.html)
# Beispiel für einen Pipeline-Resolver mit Amazon DynamoDB
Angenommen, Sie möchten einen Pipeline-Resolver an ein Feld mit dem Namen anhängen`getPost(id:ID!)`, das einen `Post` Typ aus einer Amazon DynamoDB DynamoDB-Datenquelle mit der folgenden GraphQL-Abfrage zurückgibt:
```
getPost(id:1){
id
title
content
}
```
Hängen Sie zunächst einen einfachen Resolver mit dem folgenden Code an`Query.getPost`. Dies ist ein Beispiel für einfachen Resolver-Code. Im Anforderungshandler ist keine Logik definiert, und der Antworthandler gibt einfach das Ergebnis der letzten Funktion zurück.
```
/**
* Invoked **before** the request handler of the first AppSync function in the pipeline.
* The resolver `request` handler allows to perform some preparation logic
* before executing the defined functions in your pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
return {}
}
/**
* Invoked **after** the response handler of the last AppSync function in the pipeline.
* The resolver `response` handler allows to perform some final evaluation logic
* from the output of the last function to the expected GraphQL field type.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
return ctx.prev.result
}
```
Definieren Sie als Nächstes eine Funktion`GET_ITEM`, die ein Postitem aus Ihrer Datenquelle abruft:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
/**
* Request a single item from the attached DynamoDB table datasource
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
const { id } = ctx.args
return ddb.get({ key: { id } })
}
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx
if (error) {
return util.appendError(error.message, error.type, result)
}
return ctx.result
}
```
Wenn während der Anfrage ein Fehler auftritt, hängt der Antworthandler der Funktion einen Fehler an, der in der GraphQL-Antwort an den aufrufenden Client zurückgegeben wird. Fügen Sie die `GET_ITEM` Funktion zu Ihrer Liste der Resolver-Funktionen hinzu. Wenn Sie die Abfrage ausführen, verwendet der Request-Handler der `GET_ITEM` Funktion die vom DynamoDB-Modul bereitgestellten AWS AppSync Utils, um eine `DynamoDBGetItem` Anfrage mit dem `id` als Schlüssel zu erstellen. `ddb.get({ key: { id } })`generiert die entsprechende Operation: `GetItem`
```
{
"operation" : "GetItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
AWS AppSync verwendet die Anfrage, um die Daten von Amazon DynamoDB abzurufen. Sobald die Daten zurückgegeben wurden, werden sie vom Response-Handler der `GET_ITEM` Funktion verarbeitet, der nach Fehlern sucht und dann das Ergebnis zurückgibt.
```
{
"result" : {
"id": 1,
"title": "hello world",
"content": ""
}
}
```
Schließlich gibt der Response-Handler des Resolvers das Ergebnis direkt zurück.
## Mit Fehlern arbeiten
Wenn in Ihrer Funktion während einer Anfrage ein Fehler auftritt, wird der Fehler in Ihrem Funktionsantwort-Handler unter verfügbar gemacht`ctx.error`. Sie können den Fehler mit dem Hilfsprogramm an Ihre GraphQL-Antwort anhängen. `util.appendError` Sie können den Fehler mithilfe des Stash für andere Funktionen in der Pipeline verfügbar machen. Sehen Sie sich das folgende Beispiel an:
```
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx;
if (error) {
if (!ctx.stash.errors) ctx.stash.errors = []
ctx.stash.errors.push(ctx.error)
return util.appendError(error.message, error.type, result);
}
return ctx.result;
}
```
# Dienstprogramme für die `APPSYNC_JS` Laufzeit konfigurieren
AWS AppSync stellt zwei Bibliotheken zur Verfügung, die bei der Entwicklung von Resolvern mit der `APPSYNC_JS` Runtime helfen:
+ `@aws-appsync/eslint-plugin`- Erkennt und behebt Probleme während der Entwicklung schnell.
+ `@aws-appsync/utils`- Ermöglicht Typvalidierung und Autovervollständigung in Code-Editoren.
## Konfiguration des Eslint-Plugins
[ESLint](https://eslint.org/)ist ein Tool, das Ihren Code statisch analysiert, um Probleme schnell zu finden. Sie können es ESLint als Teil Ihrer kontinuierlichen Integrationspipeline ausführen. `@aws-appsync/eslint-plugin`ist ein ESLint Plugin, das bei der Nutzung der Laufzeit ungültige Syntax in Ihrem Code erkennt. `APPSYNC_JS` Das Plugin ermöglicht es Ihnen, während der Entwicklung schnell Feedback zu Ihrem Code zu erhalten, ohne Ihre Änderungen in die Cloud übertragen zu müssen.
`@aws-appsync/eslint-plugin`bietet zwei Regelsätze, die Sie während der Entwicklung verwenden können.
**„plugin: @aws -appsync/base“** konfiguriert ein Basisregelwerk, das Sie in Ihrem Projekt nutzen können:
| Regel | Description |
| --- | --- |
| nicht asynchron | Asynchrone Prozesse und Versprechen werden nicht unterstützt. |
| kein Warten | Asynchrone Prozesse und Versprechen werden nicht unterstützt. |
| keine Klassen | Klassen werden nicht unterstützt. |
| nein für | forwird nicht unterstützt (außer für for-in undfor-of, die unterstützt werden) |
| nicht weitermachen | continue wird nicht unterstützt. |
| keine Generatoren | Generatoren werden nicht unterstützt. |
| kein Ertrag | yield wird nicht unterstützt. |
| keine Etiketten | Labels werden nicht unterstützt. |
| nein, das | thisSchlüsselwort wird nicht unterstützt. |
| versuchen Sie es nicht | Die Try/Catch-Struktur wird nicht unterstützt. |
| keine Weile | While-Loops werden nicht unterstützt. |
| no-disallowed-unary-operators | \$1\$1,--, und \$1 unäre Operatoren sind nicht zulässig. |
| no-disallowed-binary-operators | Der instanceof Operator ist nicht erlaubt. |
| kein Versprechen | Asynchrone Prozesse und Versprechen werden nicht unterstützt. |
**„plugin: @aws -appsync/recommended“** bietet einige zusätzliche Regeln, erfordert aber auch, dass Sie Ihrem Projekt Konfigurationen hinzufügen TypeScript .
| Regel | Description |
| --- | --- |
| keine Rekursion | Rekursive Funktionsaufrufen sind nicht erlaubt. |
| no-disallowed-methods | Einige Methoden sind nicht erlaubt. Eine vollständige [Liste der unterstützten integrierten Funktionen finden Sie in der Referenz](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html). |
| no-function-passing | Das Übergeben von Funktionen als Funktionsargumente an Funktionen ist nicht zulässig. |
| no-function-reassign | Funktionen können nicht neu zugewiesen werden. |
| no-function-return | Funktionen können nicht der Rückgabewert von Funktionen sein. |
Um das Plugin zu Ihrem Projekt hinzuzufügen, folgen Sie den Installations- und Nutzungsschritten unter [Erste Schritte mit ESLint](https://eslint.org/docs/latest/user-guide/getting-started#installation-and-usage). Installieren Sie dann das [Plugin](https://www.npmjs.com/package/@aws-appsync/eslint-plugin) in Ihrem Projekt mit Ihrem Projektpaketmanager (z. B. npm, yarn oder pnpm):
```
$ npm install @aws-appsync/eslint-plugin
```
Fügen Sie in Ihrer `.eslintrc.{js,yml,json}` Datei der Eigenschaft **„plugin: @aws -appsync/base“** oder **„plugin: @aws** -appsync/recommended“ hinzu. `extends` Das folgende Snippet ist eine grundlegende Beispielkonfiguration für: `.eslintrc` JavaScript
```
{
"extends": ["plugin:@aws-appsync/base"]
}
```
Um den Regelsatz **„plugin: @aws -appsync/recommended“** zu verwenden, installieren Sie die erforderliche Abhängigkeit:
```
$ npm install -D @typescript-eslint/parser
```
Erstellen Sie dann eine Datei: `.eslintrc.js`
```
{
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaVersion": 2018,
"project": "./tsconfig.json"
},
"extends": ["plugin:@aws-appsync/recommended"]
}
```
# Bündelung TypeScript, und Quellzuordnungen für die Laufzeit `APPSYNC_JS`
TypeScript verbessert die AWS AppSync Entwicklung durch Typsicherheit und frühzeitige Fehlererkennung. Sie können TypeScript Code lokal schreiben und ihn transpilieren, JavaScript bevor Sie ihn mit der `APPSYNC_JS` Runtime verwenden. Der Prozess beginnt mit der Installation TypeScript und Konfiguration von tsconfig.json für die Umgebung. `APPSYNC_JS` Anschließend können Sie Bündelungstools wie esbuild verwenden, um den Code zu kompilieren und zu bündeln. Die Amplify-CLI generiert Typen aus dem GraphQL-Schema, sodass Sie diese Typen im Resolver-Code verwenden können.
Sie können benutzerdefinierte und externe Bibliotheken in Ihrem Resolver und Funktionscode nutzen, sofern diese den Anforderungen entsprechen. `APPSYNC_JS` Bündelungstools kombinieren Code in einer einzigen Datei zur Verwendung in. AWS AppSync Quellzuordnungen können hinzugefügt werden, um das Debuggen zu erleichtern.
## Nutzen Sie Bibliotheken und bündeln Sie Ihren Code
In Ihrem Resolver und Funktionscode können Sie sowohl benutzerdefinierte als auch externe Bibliotheken nutzen, sofern sie den Anforderungen entsprechen. `APPSYNC_JS` Dadurch ist es möglich, vorhandenen Code in Ihrer Anwendung wiederzuverwenden. Um Bibliotheken zu verwenden, die durch mehrere Dateien definiert sind, müssen Sie ein Bündelungstool wie [Esbuild](https://esbuild.github.io/) verwenden, um Ihren Code in einer einzigen Datei zu kombinieren, die dann auf Ihrem AWS AppSync Resolver oder Ihrer Funktion gespeichert werden kann.
Beachten Sie beim Bündeln Ihres Codes Folgendes:
+ `APPSYNC_JS`unterstützt nur ECMAScript Module (ESM).
+ `@aws-appsync/*`Module sind in Ihren Code integriert `APPSYNC_JS` und sollten nicht mit diesem gebündelt werden.
+ Die `APPSYNC_JS` Laufzeitumgebung ähnelt NodeJS darin, dass Code nicht in einer Browserumgebung ausgeführt wird.
+ Sie können eine optionale Quellzuordnung hinzufügen. Schließen Sie den Quellinhalt jedoch nicht ein.
Weitere Informationen zu Quellzuordnungen finden Sie unter [Quellzuordnungen verwenden](#source-maps).
Um beispielsweise Ihren Resolver-Code unter zu bündeln`src/appsync/getPost.resolver.js`, können Sie den folgenden esbuild-CLI-Befehl verwenden:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/getPost.resolver.js
```
## Erstellen Sie Ihren Code und arbeiten Sie mit TypeScript
[TypeScript](https://www.typescriptlang.org/)ist eine von Microsoft entwickelte Programmiersprache, die alle Funktionen zusammen mit dem TypeScript Tippsystem bietet. JavaScript Sie können TypeScript damit typsicheren Code schreiben und Fehler und Bugs bei der Erstellung abfangen, bevor Sie Ihren Code unter speichern. AWS AppSync Das `@aws-appsync/utils` Paket ist vollständig typisiert.
Die `APPSYNC_JS` Runtime unterstützt nicht TypeScript direkt. Sie müssen Ihren TypeScript Code zuerst in Code transpilieren JavaScript , den die `APPSYNC_JS` Runtime unterstützt, bevor Sie Ihren Code darin AWS AppSync speichern. Sie können TypeScript damit Ihren Code in Ihrer lokalen integrierten Entwicklungsumgebung (IDE) schreiben. Beachten Sie jedoch, dass Sie in der AWS AppSync Konsole keinen TypeScript Code erstellen können.
Stellen Sie zunächst sicher, dass Sie die [TypeScript](https://www.typescriptlang.org/download)Installation in Ihrem Projekt installiert haben. Konfigurieren Sie dann Ihre Einstellungen für die TypeScript Transkompilierung so, dass sie mit der `APPSYNC_JS` Laufzeitumgebung funktionieren. [TSConfig](https://www.typescriptlang.org/tsconfig) Hier ist ein Beispiel für eine `tsconfig.json` Basisdatei, die Sie verwenden können:
```
// tsconfig.json
{
"compilerOptions": {
"target": "esnext",
"module": "esnext",
"noEmit": true,
"moduleResolution": "node",
}
}
```
Sie können dann ein Bündelungstool wie esbuild verwenden, um Ihren Code zu kompilieren und zu bündeln. Bei einem Projekt, in dem sich Ihr AWS AppSync Code befindet, können Sie beispielsweise den folgenden Befehl verwenden`src/appsync`, um Ihren Code zu kompilieren und zu bündeln:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/**/*.ts
```
### Verwenden von Amplify Codegen
Sie können die [Amplify CLI](https://docs.amplify.aws/cli/) verwenden, um die Typen für Ihr Schema zu generieren. Führen Sie in dem Verzeichnis, in dem sich Ihre `schema.graphql` Datei befindet, den folgenden Befehl aus und überprüfen Sie die Eingabeaufforderungen zur Konfiguration Ihres Codegens:
```
$ npx @aws-amplify/cli codegen add
```
Um Ihr Codegen unter bestimmten Umständen neu zu generieren (z. B. wenn Ihr Schema aktualisiert wird), führen Sie den folgenden Befehl aus:
```
$ npx @aws-amplify/cli codegen
```
Sie können dann die generierten Typen in Ihrem Resolver-Code verwenden. Zum Beispiel anhand des folgenden Schemas:
```
type Todo {
id: ID!
title: String!
description: String
}
type Mutation {
createTodo(title: String!, description: String): Todo
}
type Query {
listTodos: Todo
}
```
Sie könnten die generierten Typen in der folgenden AWS AppSync Beispielfunktion verwenden:
```
import { Context, util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
import { CreateTodoMutationVariables, Todo } from './API' // codegen
export function request(ctx: Context) {
ctx.args.description = ctx.args.description ?? 'created on ' + util.time.nowISO8601()
return ddb.put({ key: { id: util.autoId() }, item: ctx.args })
}
export function response(ctx) {
return ctx.result as Todo
}
```
### Verwendung von Generika in TypeScript
Sie können Generika mit mehreren der bereitgestellten Typen verwenden. Das folgende Snippet ist beispielsweise ein Typ: `Todo`
```
export type Todo = {
__typename: "Todo",
id: string,
title: string,
description?: string | null,
};
```
Sie können einen Resolver für ein Abonnement schreiben, das von verwendet. `Todo` In Ihrer IDE führen Sie Typdefinitionen und Hinweise zur automatischen Vervollständigung dazu, das `toSubscriptionFilter` Transform-Hilfsprogramm richtig zu verwenden:
```
import { util, Context, extensions } from '@aws-appsync/utils'
import { Todo } from './API'
export function request(ctx: Context) {
return {}
}
export function response(ctx: Context) {
const filter = util.transform.toSubscriptionFilter({
title: { beginsWith: 'hello' },
description: { contains: 'created' },
})
extensions.setSubscriptionFilter(filter)
return null
}
```
## Deine Bündel einbinden
Du kannst deine Bundles automatisch fesseln, indem du das Plugin importierst. `esbuild-plugin-eslint` Sie können es dann aktivieren, indem Sie einen `plugins` Wert angeben, der die Eslint-Funktionen aktiviert. Unten finden Sie ein Snippet, das die JavaScript Esbuild-API in einer Datei namens verwendet: `build.mjs`
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
## Quellzuordnungen verwenden
Sie können eine Inline-Quellkarte (`sourcemap`) mit Ihrem JavaScript Code bereitstellen. Quellzuordnungen sind nützlich, wenn Sie bündeln JavaScript oder TypeScript programmieren und Verweise auf Ihre Eingabequelldateien in Ihren Protokollen und JavaScript Laufzeitfehlermeldungen sehen möchten.
Sie `sourcemap` müssen am Ende Ihres Codes erscheinen. Es wird durch eine einzelne Kommentarzeile definiert, die dem folgenden Format folgt:
```
//# sourceMappingURL=data:application/json;base64,
```
Hier ein Beispiel:
```
//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsibGliLmpzIiwgImNvZGUuanMiXSwKICAibWFwcGluZ3MiOiAiO0FBQU8sU0FBUyxRQUFRO0FBQ3RCLFNBQU87QUFDVDs7O0FDRE8sU0FBUyxRQUFRLEtBQUs7QUFDM0IsU0FBTyxNQUFNO0FBQ2Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
```
Quellzuordnungen können mit esbuild erstellt werden. Das folgende Beispiel zeigt Ihnen, wie Sie die JavaScript Esbuild-API verwenden, um beim Erstellen und Bündeln von Code eine Inline-Quellenzuweisung einzubeziehen:
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
sourcemap: 'inline',
sourcesContent: false,
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
Insbesondere geben die `sourcesContent` Optionen `sourcemap` und an, dass am Ende jedes Builds eine Quellzuordnung in der Zeile hinzugefügt werden soll, den Quellinhalt jedoch nicht enthalten sollte. Als Konvention empfehlen wir, keine Quellinhalte in Ihre aufzunehmen`sourcemap`. Sie können dies in Esbuild deaktivieren, indem Sie `sources-content` auf `false` setzen.
Um zu veranschaulichen, wie Quellzuordnungen funktionieren, sehen Sie sich das folgende Beispiel an, in dem ein Resolver-Code auf Hilfsfunktionen aus einer Hilfsbibliothek verweist. Der Code enthält Protokollanweisungen im Resolver-Code und in der Hilfsbibliothek:
**. /src/default.resolver.ts** (dein Resolver)
```
import { Context } from '@aws-appsync/utils'
import { hello, logit } from './helper'
export function request(ctx: Context) {
console.log('start >')
logit('hello world', 42, true)
console.log('< end')
return 'test'
}
export function response(ctx: Context): boolean {
hello()
return ctx.prev.result
}
```
**.src/helper.ts** (eine Hilfsdatei)
```
export const logit = (...rest: any[]) => {
// a special logger
console.log('[logger]', ...rest.map((r) => `<${r}>`))
}
export const hello = () => {
// This just returns a simple sentence, but it could do more.
console.log('i just say hello..')
}
```
Wenn Sie die Resolver-Datei erstellen und bündeln, enthält Ihr Resolver-Code eine Inline-Quellzuweisung. Wenn Ihr Resolver ausgeführt wird, erscheinen die folgenden Einträge in den Protokollen: CloudWatch
![\[CloudWatch log entries showing resolver code execution with inline source map information.\]](http://docs.aws.amazon.com/de_de/appsync/latest/devguide/images/cloudwatch-sourcemap.jpeg)
Wenn Sie sich die Einträge im CloudWatch Protokoll ansehen, werden Sie feststellen, dass die Funktionalität der beiden Dateien gebündelt wurde und gleichzeitig ausgeführt wird. Der ursprüngliche Dateiname jeder Datei spiegelt sich auch deutlich in den Protokollen wider.
# Testen Sie Ihren Resolver und Ihre Funktionshandler in AWS AppSync
Sie können den `EvaluateCode` API-Befehl verwenden, um Ihren Resolver und Funktionshandler aus der Ferne mit gefälschten Daten zu testen, bevor Sie Ihren Code in einem Resolver oder einer Funktion speichern. Um mit dem Befehl zu beginnen, stellen Sie sicher, dass Sie die `appsync:evaluatecode` entsprechende Berechtigung zu Ihrer Richtlinie hinzugefügt haben. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Sie können den Befehl nutzen, indem Sie die [AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/index.html) oder verwenden [AWS SDKs](https://aws.amazon.com/tools/). Um beispielsweise Ihren Code mit der CLI zu testen, zeigen Sie einfach auf Ihre Datei, geben Sie einen Kontext an und geben Sie den Handler an, den Sie auswerten möchten:
```
aws appsync evaluate-code \
--code file://code.js \
--function request \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
Die Antwort `evaluationResult` enthält eine, die die von Ihrem Handler zurückgegebene Nutzlast enthält. Es enthält auch ein `logs` Objekt, das die Liste der Protokolle enthält, die von Ihrem Handler während der Auswertung generiert wurden. Auf diese Weise können Sie Ihre Codeausführung einfach debuggen und Informationen zu Ihrer Evaluierung abrufen, um die Fehlerbehebung zu erleichtern. Beispiel:
```
{
"evaluationResult": "{\"operation\":\"PutItem\",\"key\":{\"id\":{\"S\":\"record-id\"}},\"attributeValues\":{\"owner\":{\"S\":\"John doe\"},\"expectedVersion\":{\"N\":2},\"authorId\":{\"S\":\"Sammy Davis\"}}}",
"logs": [
"INFO - code.js:5:3: \"current id\" \"record-id\"",
"INFO - code.js:9:3: \"request evaluated\""
]
}
```
Das Evaluationsergebnis kann als JSON analysiert werden, was Folgendes ergibt:
```
{
"operation": "PutItem",
"key": {
"id": {
"S": "record-id"
}
},
"attributeValues": {
"owner": {
"S": "John doe"
},
"expectedVersion": {
"N": 2
},
"authorId": {
"S": "Sammy Davis"
}
}
}
```
Mit dem SDK können Sie auf einfache Weise Tests aus Ihrer Testsuite integrieren, um das Verhalten Ihres Codes zu überprüfen. Unser Beispiel hier verwendet das [Jest Testing Framework](https://jestjs.io/), aber jede Testsuite funktioniert. Der folgende Ausschnitt zeigt einen hypothetischen Validierungslauf. Beachten Sie, dass wir davon ausgehen, dass es sich bei der Bewertungsantwort um ein gültiges JSON handelt. Daher verwenden wir diese Methode, `JSON.parse` um JSON aus der Zeichenkettenantwort abzurufen:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Dies führt zu dem folgenden Ergebnis:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
# Migration von VTL zu in JavaScript AWS AppSync
AWS AppSync ermöglicht es Ihnen, Ihre Geschäftslogik für Ihre Resolver und Funktionen mit VTL oder zu schreiben. JavaScript In beiden Sprachen schreiben Sie eine Logik, die den AWS AppSync Service anweist, wie er mit Ihren Datenquellen interagieren soll. Mit VTL schreiben Sie Zuordnungsvorlagen, die eine gültige JSON-kodierte Zeichenfolge ergeben müssen. Mit schreiben Sie JavaScript Anforderungs- und Antworthandler, die Objekte zurückgeben. Sie geben keine JSON-kodierte Zeichenfolge zurück.
Verwenden Sie zum Beispiel die folgende VTL-Zuordnungsvorlage, um ein Amazon DynamoDB DynamoDB-Element abzurufen:
```
{
"operation": "GetItem",
"key": {
"id": $util.dynamodb.toDynamoDBJson($ctx.args.id),
}
}
```
Das Hilfsprogramm `$util.dynamodb.toDynamoDBJson` gibt eine JSON-kodierte Zeichenfolge zurück. Wenn auf gesetzt `$ctx.args.id` ist``, ergibt die Vorlage eine gültige JSON-kodierte Zeichenfolge:
```
{
"operation": "GetItem",
"key": {
"id": {"S": ""},
}
}
```
Wenn Sie mit arbeiten JavaScript, müssen Sie keine rohen JSON-codierten Zeichenketten in Ihrem Code ausdrucken, und die Verwendung eines Hilfsprogramms wie ist nicht erforderlich. `toDynamoDBJson` Ein äquivalentes Beispiel für die obige Mapping-Vorlage ist:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: {id: util.dynamodb.toDynamoDB(ctx.args.id)}
};
}
```
Eine Alternative ist die Verwendung `util.dynamodb.toMapValues` des empfohlenen Ansatzes zur Behandlung eines Werteobjekts:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
Das ergibt:
```
{
"operation": "GetItem",
"key": {
"id": {
"S": ""
}
}
}
```
**Anmerkung**
Wir empfehlen, das DynamoDB-Modul mit DynamoDB-Datenquellen zu verwenden:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
ddb.get({ key: { id: ctx.args.id } })
}
```
Nehmen Sie als weiteres Beispiel die folgende Zuordnungsvorlage, um ein Element in eine Amazon DynamoDB DynamoDB-Datenquelle einzufügen:
```
{
"operation" : "PutItem",
"key" : {
"id": $util.dynamodb.toDynamoDBJson($util.autoId()),
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Bei der Auswertung muss diese Zeichenfolge für die Zuordnungsvorlage eine gültige JSON-kodierte Zeichenfolge ergeben. Bei Verwendung gibt Ihr Code JavaScript das Anforderungsobjekt direkt zurück:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id = util.autoId(), ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
was wie folgt ausgewertet wird:
```
{
"operation": "PutItem",
"key": {
"id": { "S": "2bff3f05-ff8c-4ed8-92b4-767e29fc4e63" }
},
"attributeValues": {
"firstname": { "S": "Shaggy" },
"age": { "N": 4 }
}
}
```
**Anmerkung**
Wir empfehlen, das DynamoDB-Modul mit DynamoDB-Datenquellen zu verwenden:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const { id = util.autoId(), ...item } = ctx.args
return ddb.put({ key: { id }, item })
}
```
# Wahl zwischen direktem Datenquellenzugriff und Proxying über eine Lambda-Datenquelle
Mit AWS AppSync und der `APPSYNC_JS` Runtime können Sie Ihren eigenen Code schreiben, der Ihre benutzerdefinierte Geschäftslogik implementiert, indem Sie AWS AppSync Funktionen für den Zugriff auf Ihre Datenquellen verwenden. Dies erleichtert Ihnen die direkte Interaktion mit Datenquellen wie Amazon DynamoDB, Aurora Serverless, OpenSearch Service, HTTP und anderen AWS Diensten APIs, ohne zusätzliche Rechendienste oder Infrastruktur bereitstellen zu müssen. AWS AppSync macht es auch einfach, mit einer AWS Lambda Funktion zu interagieren, indem eine Lambda-Datenquelle konfiguriert wird. Mit Lambda-Datenquellen können Sie komplexe Geschäftslogik ausführen und dabei alle Funktionen nutzen AWS Lambda, um eine GraphQL-Anfrage zu lösen. In den meisten Fällen bietet eine AWS AppSync Funktion, die direkt mit der Zieldatenquelle verbunden ist, alle Funktionen, die Sie benötigen. In Situationen, in denen Sie komplexe Geschäftslogik implementieren müssen, die von der `APPSYNC_JS` Laufzeit nicht unterstützt wird, können Sie eine Lambda-Datenquelle als Proxy für die Interaktion mit Ihrer Zieldatenquelle verwenden.
| | | |
| --- |--- |--- |
| | Direkte Datenquellenintegration | Lambda-Datenquelle als Proxy |
| Anwendungsfall | AWS AppSync Funktionen interagieren direkt mit API-Datenquellen. | AWS AppSync Funktionen rufen Lambdas auf, die mit API-Datenquellen interagieren. |
| Laufzeit | APPSYNC\$1JS (JavaScript) | Jede unterstützte Lambda-Laufzeit |
| Maximale Größe des Codes | 32.000 Zeichen pro Funktion AWS AppSync | 50 MB (gezippt, für direkten Upload) pro Lambda |
| Externe Module | Eingeschränkt — nur von APPSYNC\$1JS unterstützte Funktionen | Ja |
| Rufen Sie einen beliebigen Dienst an AWS | Ja, es wird eine AWS AppSync HTTP-Datenquelle verwendet | Ja — SDK verwenden AWS |
| Zugriff auf den Anforderungsheader | Ja | Ja |
| Netzwerkzugriff | Nein | Ja |
| Zugriff auf das Dateisystem | Nein | Ja |
| Protokollierung und Metriken | Ja | Ja |
| Entwickeln und testen Sie komplett innerhalb AppSync | Ja | Nein |
| Kaltstart | Nein | Nein — Mit bereitgestellter Parallelität |
| Auto Scaling | Ja — transparent von AWS AppSync | Ja — Wie in Lambda konfiguriert |
| Preisgestaltung | Keine zusätzlichen Kosten | Wird für die Nutzung von Lambda berechnet |
AWS AppSync Funktionen, die sich direkt in ihre Zieldatenquelle integrieren lassen, eignen sich ideal für Anwendungsfälle wie die folgenden:
+ Interaktion mit Amazon DynamoDB, Aurora Serverless und Service OpenSearch
+ Interaktion mit HTTP APIs und Weitergabe eingehender Header
+ Interaktion mit AWS Diensten, die HTTP-Datenquellen verwenden (mit AWS AppSync automatischem Signieren von Anfragen mit der angegebenen Datenquellenrolle)
+ Implementierung der Zugriffskontrolle vor dem Zugriff auf Datenquellen
+ Implementierung der Filterung der abgerufenen Daten vor der Erfüllung einer Anfrage
+ Implementierung einer einfachen Orchestrierung mit sequentieller Ausführung von AWS AppSync Funktionen in einer Resolver-Pipeline
+ Steuerung von Caching- und Abonnementverbindungen bei Abfragen und Mutationen.
AWS AppSync Funktionen, die eine Lambda-Datenquelle als Proxy verwenden, eignen sich ideal für Anwendungsfälle wie die folgenden:
+ Verwenden Sie eine andere Sprache als JavaScript Velocity Template Language (VTL)
+ Anpassung und Steuerung der CPU oder des Speichers zur Leistungsoptimierung
+ Importieren von Bibliotheken von Drittanbietern oder Anfordern nicht unterstützter Funktionen in `APPSYNC_JS`
+ Mehrere Netzwerkanfragen stellen, Dateisystemzugriff and/or erhalten, um eine Anfrage zu erfüllen
+ Batchverarbeitung von Anfragen mithilfe der [Batching-Konfiguration](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html).