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 Resolver-Referenz () JavaScript
Die folgenden Abschnitte enthalten die `APPSYNC_JS` Laufzeit- und JavaScript Resolver-Referenz:
+ [ JavaScriptÜbersicht über Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) — Erfahren Sie mehr über die Funktionsweise von Resolvern in. AWS AppSync
+ [Objektreferenz für den Resolver-Kontext](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) — Erfahren Sie mehr über das Kontextobjekt und seine Verwendung in Resolvern.
+ [ JavaScript Laufzeitfunktionen für Resolver und Funktionen](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) — Erfahren Sie mehr über unterstützte Runtime-Funktionen und die Verwendung von Hilfsprogrammen zur Codevereinfachung.
+ [ JavaScriptResolver-Funktionsreferenz für DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) — Erfahren Sie mehr darüber, wie Resolver mit DynamoDB interagieren.
+ [ JavaScriptReferenz zur Resolver-Funktion für OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-elasticsearch-js.html) — Erfahren Sie mehr über die Struktur von Anfragen und Antworten auf Resolver sowie über Interaktionen mit dem Service. OpenSearch
+ [ JavaScript Resolver-Funktionsreferenz für Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html) — Erfahren Sie mehr über die Resolver-Anfrage- und Antwortstruktur und Interaktionen mit Lambda.
+ [ JavaScriptResolver-Funktionsreferenz für die EventBridge Datenquelle](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-eventbridge-js.html) — Erfahren Sie mehr über die Resolver-Anfrage- und Antwortstruktur und Interaktionen mit. EventBridge
+ [ JavaScript Referenz zur Resolverfunktion für die Datenquelle None](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-none-js.html) — Erfahren Sie mehr über die Anforderungs- und Antwortstruktur des Resolvers sowie über Interaktionen mit NONE-Datenquellen.
+ [ JavaScript Resolver-Funktionsreferenz für HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-http-js.html) — Erfahren Sie mehr über die Resolver-Anforderungs- und Antwortstruktur und Interaktionen mit HTTP-Endpunkten.
+ [ JavaScript Resolver-Funktionsreferenz für Amazon RDS](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-rds-js.html) — Erfahren Sie mehr über die Resolver-Struktur und Interaktionen mit RDS.
+ [ JavaScript Resolver-Funktionsreferenz für Amazon Bedrock](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-bedrock-js.html) — Erfahren Sie mehr über die Resolver-Struktur und Interaktionen mit Amazon Bedrock.
# 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).
# AWS AppSync JavaScript Resolver-Kontext-Objektreferenz
AWS AppSync definiert eine Reihe von Variablen und Funktionen für die Arbeit mit Anfrage- und Antworthandlern. Dies erleichtert logische Operationen an Daten mit GraphQL. Dieses Dokument beschreibt diese Funktionen und enthält Beispiele.
## Zugreifen auf den `context`
Das `context` Argument eines Request- und Response-Handlers ist ein Objekt, das alle Kontextinformationen für Ihren Resolver-Aufruf enthält. Sie hat die folgende Struktur:
```
type Context = {
arguments: any;
args: any;
identity: Identity;
source: any;
error?: {
message: string;
type: string;
};
stash: any;
result: any;
prev: any;
request: Request;
info: Info;
};
```
**Anmerkung**
Sie werden häufig feststellen, dass das `context` Objekt als bezeichnet wird. `ctx`
Jedes Feld im `context` Objekt ist wie folgt definiert:
### `context`-Felder
** `arguments` **
Eine Zuordnung, die alle GraphQL-Argumente für dieses Feld enthält.
** `identity` **
Ein Objekt, das Informationen über den Aufrufer enthält. Weitere Informationen zur Struktur dieses Felds finden Sie unter [Identity](#aws-appsync-resolver-context-reference-identity-js).
** `source` **
Eine Zuordnung, die die Auflösung des übergeordneten Feldes enthält.
** `stash` **
Der Stash ist ein Objekt, das in jedem Resolver und Funktionshandler verfügbar gemacht wird. Das gleiche Stash-Objekt 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 nicht den gesamten Stash löschen oder ersetzen, aber Sie können Eigenschaften des Stashs hinzufügen, aktualisieren, löschen und lesen.
Sie können dem Stash Elemente hinzufügen, indem Sie eines der folgenden Codebeispiele ändern:
```
//Example 1
ctx.stash.newItem = { key: "something" }
//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Sie können Artikel aus dem Stash entfernen, indem Sie den folgenden Code ändern:
```
delete ctx.stash.key
```
** `result` **
Ein Container für die Ergebnisse dieses Resolvers. Dieses Feld ist nur für Antworthandler verfügbar.
Zum Beispiel, wenn Sie das `author` Feld der folgenden Abfrage auflösen:
```
query {
getPost(id: 1234) {
postId
title
content
author {
id
name
}
}
}
```
Dann ist die vollständige `context` Variable verfügbar, wenn ein Antworthandler ausgewertet wird:
```
{
"arguments" : {
id: "1234"
},
"source": {},
"result" : {
"postId": "1234",
"title": "Some title",
"content": "Some content",
"author": {
"id": "5678",
"name": "Author Name"
}
},
"identity" : {
"sourceIp" : ["x.x.x.x"],
"userArn" : "arn:aws:iam::123456789012:user/appsync",
"accountId" : "666666666666",
"user" : "AIDAAAAAAAAAAAAAAAAAA"
}
}
```
** `prev.result` **
Das Ergebnis einer beliebigen vorherigen Operation, die in einem Pipeline-Resolver ausgeführt wurde.
Wenn der vorherige Vorgang der Anforderungshandler des Pipeline-Resolvers war, `ctx.prev.result` stellt er dieses Auswertungsergebnis dar und wird der ersten Funktion in der Pipeline zur Verfügung gestellt.
Wenn die vorherige Operation die erste Funktion war, `ctx.prev.result` stellt sie das Auswertungsergebnis des Antworthandlers der ersten Funktion dar und wird der zweiten Funktion in der Pipeline zur Verfügung gestellt.
Wenn die vorherige Operation die letzte Funktion war, `ctx.prev.result` stellt sie das Auswertungsergebnis der letzten Funktion dar und wird dem Response-Handler des Pipeline-Resolvers zur Verfügung gestellt.
** `info` **
Ein Objekt, das Informationen über die GraphQL-Anforderung enthält. Die Struktur dieses Feldes finden Sie unter [Info](#aws-appsync-resolver-context-reference-info-js).
### Identität
Der Abschnitt `identity` enthält Informationen über den Aufrufer. Die Form dieses Abschnitts hängt vom Autorisierungstyp Ihrer AWS AppSync API ab.
Weitere Informationen zu AWS AppSync Sicherheitsoptionen finden Sie unter [Autorisierung und Authentifizierung](security-authz.md#aws-appsync-security).
** `API_KEY`-Autorisierung**
Das `identity` Feld ist nicht gefüllt.
**`AWS_LAMBDA`-Autorisierung**
Das `identity` hat die folgende Form:
```
type AppSyncIdentityLambda = {
resolverContext: any;
};
```
Der `identity` enthält den `resolverContext` Schlüssel, der denselben `resolverContext` Inhalt enthält, der von der Lambda-Funktion zurückgegeben wurde, die die Anfrage autorisiert.
** `AWS_IAM`-Autorisierung**
Der `identity` hat die folgende Form:
```
type AppSyncIdentityIAM = {
accountId: string;
cognitoIdentityPoolId: string;
cognitoIdentityId: string;
sourceIp: string[];
username: string;
userArn: string;
cognitoIdentityAuthType: string;
cognitoIdentityAuthProvider: string;
};
```
** `AMAZON_COGNITO_USER_POOLS`-Autorisierung**
Der `identity` hat die folgende Form:
```
type AppSyncIdentityCognito = {
sourceIp: string[];
username: string;
groups: string[] | null;
sub: string;
issuer: string;
claims: any;
defaultAuthStrategy: string;
};
```
Jedes Feld ist wie folgt definiert:
** `accountId` **
Die AWS Konto-ID des Anrufers.
** `claims` **
Die Ansprüche, die der Benutzer hat.
** `cognitoIdentityAuthType` **
Entweder authentifiziert oder nicht authentifiziert, basierend auf dem Identitätstyp.
** `cognitoIdentityAuthProvider` **
Eine durch Kommas getrennte Liste mit Informationen zu externen Identitätsanbietern, anhand derer die Anmeldeinformationen abgerufen wurden, mit denen die Anfrage signiert wurde.
** `cognitoIdentityId` **
Die Amazon Cognito Cognito-Identitäts-ID des Anrufers.
** `cognitoIdentityPoolId` **
Die dem Anrufer zugeordnete Amazon Cognito Cognito-Identitätspool-ID.
** `defaultAuthStrategy` **
Die Standardautorisierungsstrategie für diesen Aufrufer (`ALLOW` oder `DENY`).
** `issuer` **
Der Aussteller des Tokens.
** `sourceIp` **
Die Quell-IP-Adresse des Anrufers, der empfängt. AWS AppSync Wenn die Anfrage den `x-forwarded-for` Header nicht enthält, enthält der Quell-IP-Wert nur eine einzige IP-Adresse aus der TCP-Verbindung. Wenn die Anforderung einen `x-forwarded-for`-Header enthält, verfügt die Quell-IP zusätzlich zur IP-Adresse aus der TCP-Verbindung über eine Liste mit IP-Adressen aus dem `x-forwarded-for`-Header.
** `sub` **
Die UUID des authentifizierten Benutzers.
** `user` **
Der IAM-Benutzer.
** `userArn` **
Der Amazon-Ressourcenname (ARN) des IAM-Benutzers.
** `username` **
Der Benutzername des authentifizierten Benutzers. Bei einer `AMAZON_COGNITO_USER_POOLS`-Autorisierung ist der Wert des *Benutzernamens* der Wert des Attributs *cognito:username*. Im Fall einer `AWS_IAM` Autorisierung entspricht der Wert von *username* dem Wert des AWS Benutzerprinzipals. Wenn Sie die IAM-Autorisierung mit Anmeldeinformationen verwenden, die aus Amazon Cognito Cognito-Identitätspools stammen, empfehlen wir Ihnen, diese zu verwenden. `cognitoIdentityId`
### Auf Header von Anfragen zugreifen
AWS AppSync unterstützt die Übergabe benutzerdefinierter Header von Clients und den Zugriff auf sie in Ihren GraphQL-Resolvern mithilfe von. `ctx.request.headers` Sie können die Header-Werte dann für Aktionen wie das Einfügen von Daten in eine Datenquelle oder für Autorisierungsprüfungen verwenden. Sie können einzelne oder mehrere Anforderungsheader `$curl` mithilfe eines API-Schlüssels von der Befehlszeile aus verwenden, wie in den folgenden Beispielen gezeigt:
**Beispiel für einen einzelnen Header**
Angenommen, Sie legen wie folgt einen `custom`-Header mit dem Wert `nadia` fest:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Darauf könnte dann mit `ctx.request.headers.custom` zugegriffen werden. Es könnte beispielsweise im folgenden Code für DynamoDB enthalten sein:
```
"custom": util.dynamodb.toDynamoDB(ctx.request.headers.custom)
```
**Beispiel für mehrere Header**
Sie können auch mehrere Header in einer einzigen Anfrage übergeben und im Resolver-Handler auf diese zugreifen. Zum Beispiel, wenn der `custom` Header mit zwei Werten festgelegt ist:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Sie können dann darauf als Array zugreifen, z. B. `ctx.request.headers.custom[1]`.
**Anmerkung**
AWS AppSync macht den Cookie-Header in nicht verfügbar`ctx.request.headers`.
### Greifen Sie auf den angeforderten benutzerdefinierten Domainnamen zu
AWS AppSync unterstützt die Konfiguration einer benutzerdefinierten Domain, mit der Sie auf Ihre GraphQL- und Echtzeit-Endpunkte für Ihre zugreifen können. APIs Wenn Sie eine Anfrage mit einem benutzerdefinierten Domainnamen stellen, können Sie den Domainnamen mithilfe von abrufen. `ctx.request.domainName`
Bei Verwendung des standardmäßigen GraphQL-Endpunktdomänennamens lautet der Wert. `null`
### Info
Der Abschnitt `info` enthält Informationen über die GraphQL-Anforderung. Dieser Abschnitt hat die folgende Form:
```
type Info = {
fieldName: string;
parentTypeName: string;
variables: any;
selectionSetList: string[];
selectionSetGraphQL: string;
};
```
Jedes Feld ist wie folgt definiert:
** `fieldName` **
Der Name des Feldes, das derzeit aufgelöst wird.
** `parentTypeName` **
Der Name des übergeordneten Typs für das Feld, das derzeit aufgelöst wird.
** `variables` **
Eine Zuordnung, die alle Variablen enthält, die an die GraphQL-Anforderung übergeben werden.
** `selectionSetList` **
Eine Listendarstellung der Felder im GraphQL-Auswahlsatz. Felder mit Aliasnamen werden nur durch den Aliasnamen referenziert, nicht durch den Feldnamen. Im folgenden Beispiel ist dies detailliert dargestellt.
** `selectionSetGraphQL` **
Eine Zeichenfolgendarstellung des Auswahlsatzes, formatiert als GraphQL-Schemadefinitionssprache (SDL). Fragmente werden zwar nicht mit dem Auswahlsatz zusammengeführt, Inline-Fragmente bleiben jedoch erhalten, wie im folgenden Beispiel gezeigt.
**Anmerkung**
`JSON.stringify`schließt `selectionSetGraphQL` und nicht `selectionSetList` in die Serialisierung der Zeichenfolge ein. Sie müssen direkt auf diese Eigenschaften verweisen.
Angenommen, Sie lösen das `getPost`-Feld der folgenden Abfrage auf:
```
query {
getPost(id: $postId) {
postId
title
secondTitle: title
content
author(id: $authorId) {
authorId
name
}
secondAuthor(id: "789") {
authorId
}
... on Post {
inlineFrag: comments: {
id
}
}
... postFrag
}
}
fragment postFrag on Post {
postFrag: comments: {
id
}
}
```
Dann könnte die vollständige `ctx.info` Variable, die bei der Verarbeitung eines Handlers verfügbar ist, wie folgt lauten:
```
{
"fieldName": "getPost",
"parentTypeName": "Query",
"variables": {
"postId": "123",
"authorId": "456"
},
"selectionSetList": [
"postId",
"title",
"secondTitle"
"content",
"author",
"author/authorId",
"author/name",
"secondAuthor",
"secondAuthor/authorId",
"inlineFragComments",
"inlineFragComments/id",
"postFragComments",
"postFragComments/id"
],
"selectionSetGraphQL": "{\n getPost(id: $postId) {\n postId\n title\n secondTitle: title\n content\n author(id: $authorId) {\n authorId\n name\n }\n secondAuthor(id: \"789\") {\n authorId\n }\n ... on Post {\n inlineFrag: comments {\n id\n }\n }\n ... postFrag\n }\n}"
}
```
`selectionSetList`macht nur Felder verfügbar, die zum aktuellen Typ gehören. Wenn es sich bei dem aktuellen Typ um eine Schnittstelle oder Union handelt, werden nur ausgewählte Felder angezeigt, die zur Schnittstelle gehören. Nehmen wir zum Beispiel das folgende Schema:
```
type Query {
node(id: ID!): Node
}
interface Node {
id: ID
}
type Post implements Node {
id: ID
title: String
author: String
}
type Blog implements Node {
id: ID
title: String
category: String
}
```
Und die folgende Abfrage:
```
query {
node(id: "post1") {
id
... on Post {
title
}
... on Blog {
title
}
}
}
```
`ctx.info.selectionSetList`Beim Aufrufen mit der `Query.node` Feldauflösung `id` wird nur angezeigt:
```
"selectionSetList": [
"id"
]
```
# AWS AppSync JavaScript Laufzeitfunktionen für Resolver und Funktionen
Die `APPSYNC_JS` Laufzeitumgebung bietet ähnliche Funktionen wie [ECMAScript (ES) Version 6.0](https://262.ecma-international.org/6.0/). Sie unterstützt einen Teil ihrer Funktionen und bietet einige zusätzliche Methoden (Dienstprogramme), die nicht Teil der ES-Spezifikationen sind. In den folgenden Themen sind alle unterstützten Sprachfunktionen aufgeführt:
+ [Unterstützte Laufzeitfunktionen](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html) — Erfahren Sie mehr über unterstützte Kernfunktionen, primitive Objekte, integrierte Objekte und Funktionen usw.
+ [Integrierte Hilfsprogramme](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) — Die Variable util enthält allgemeine Hilfsmethoden, die Ihnen bei der Arbeit mit Daten helfen. Sofern nicht anders angegeben, verwenden alle Dienstprogramme den UTF-8-Zeichensatz.
+ [Integrierte Module](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) — Erfahren Sie mehr darüber, wie integrierte Module beim Schreiben von JavaScript Resolvern und Funktionen helfen können.
+ [Runtime-Utilities](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html) — Die Runtime-Bibliothek stellt Dienstprogramme zur Verfügung, mit denen Sie die Laufzeiteigenschaften Ihrer Resolver und Funktionen steuern oder ändern können.
+ [Zeithelfer in util.time — Die Variable util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) enthält Datetime-Methoden, mit deren Hilfe Zeitstempel generiert, zwischen Datetime-Formaten konvertiert und Datetime-Zeichenketten analysiert werden können. Darauf basiert die Syntax für Datetime-Formate, auf die Sie sich für weitere Dokumentationen beziehen können. [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
+ [DynamoDB-Helfer in util.dynamodb — util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) enthält Hilfsmethoden, die das Schreiben und Lesen von Daten in Amazon DynamoDB erleichtern, wie z. B. automatische Typzuweisung und Formatierung.
+ [HTTP-Helfer in util.http — Das Hilfsprogramm util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) bietet Hilfsmethoden, mit denen Sie HTTP-Anforderungsparameter verwalten und Antwortheader hinzufügen können.
+ [Transformationshelfer in util.transform - util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) enthält Hilfsmethoden, die es einfacher machen, komplexe Operationen mit Datenquellen durchzuführen.
+ [Zeichenkettenhelfer in util.str - util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) enthält Methoden, die bei gängigen String-Operationen helfen.
+ [Erweiterungen — Erweiterungen](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) enthalten eine Reihe von Methoden, mit denen Sie zusätzliche Aktionen in Ihren Resolvern ausführen können.
+ [XML-Helfer in util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml enthält Methoden, die bei der Konvertierung von XML-Zeichenketten helfen.
**Anmerkung**
Derzeit gilt diese Referenz nur für Runtime-Version **1.0.0**.
# Unterstützte Runtime-Funktionen
In den folgenden Abschnitten werden die unterstützten Funktionen der APPSYNC\$1JS-Laufzeit beschrieben.
## Kern-Features
Die folgenden Kernfunktionen werden unterstützt.
------
#### [ Types ]
Die folgenden Typen werden unterstützt:
+ Ziffern
+ Zeichenfolgen
+ Boolesche Werte
+ objects
+ Arrays
+ Funktionen
------
#### [ Operators ]
Operatoren werden unterstützt, darunter:
+ mathematische Standardoperatoren (`+``-``/`,`%`,`*`,, usw.)
+ Koaleszenzoperator () auf Null setzen `??`
+ Optionale Verkettung () `?.`
+ bitweise Operatoren
+ `void`und Operatoren `typeof`
+ Spread-Operatoren (`...`)
Die folgenden Operatoren werden nicht unterstützt:
+ unäre Operatoren (`++``--`, und`~`)
+ `in`-Operator
**Anmerkung**
Verwenden Sie den `Object.hasOwn` Operator, um zu überprüfen, ob sich die angegebene Eigenschaft im angegebenen Objekt befindet.
------
#### [ Statements ]
Die folgenden Anweisungen werden unterstützt:
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ Spread-Syntax
Folgendes wird nicht unterstützt:
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**Anmerkung**
Die Ausnahmen sind `for-in` und `for-of` Ausdrücke, die unterstützt werden.
+ `throw`
+ `try`
+ `while`
+ beschriftete Aussagen
------
#### [ Literals ]
Die folgenden ES [6-Vorlagenliterale](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) werden unterstützt:
+ Mehrzeilige Zeichenketten
+ Interpolation von Ausdrücken
+ Verschachtelte Vorlagen
------
#### [ Functions ]
Die folgende Funktionssyntax wird unterstützt:
+ Funktionsdeklarationen werden unterstützt.
+ ES 6-Pfeilfunktionen werden unterstützt.
+ Die ES 6-Restparameter-Syntax wird unterstützt.
------
#### [ Strict mode ]
Funktionen arbeiten standardmäßig im strikten Modus, sodass Sie Ihrem Funktionscode keine `use_strict`-Anweisung hinzufügen müssen. Dies können nicht geändert werden.
------
## Primitive Objekte
Die folgenden primitiven Objekte von ES und ihre Funktionen werden unterstützt.
------
#### [ Object ]
Die folgenden Objekte werden unterstützt:
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
Die folgenden Zeichenketten werden unterstützt:
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**Anmerkung**
Reguläre Ausdrücke werden nicht unterstützt.
Konstrukte regulärer Ausdrücke im Java-Stil werden jedoch im angegebenen Parameter unterstützt. [Weitere Informationen finden Sie unter Muster.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+ `String.prototype.replaceAll()`
**Anmerkung**
Reguläre Ausdrücke werden nicht unterstützt.
Konstrukte regulärer Ausdrücke im Java-Stil werden jedoch im angegebenen Parameter unterstützt. [Weitere Informationen finden Sie unter Muster.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html)
+ `String.prototype.slice()`
+ `String.prototype.split()`
+ `String.prototype.startsWith()`
+ `String.prototype.toLowerCase()`
+ `String.prototype.toUpperCase()`
+ `String.prototype.trim()`
+ `String.prototype.trimEnd()`
+ `String.prototype.trimStart()`
------
#### [ Number ]
Die folgenden Zahlen werden unterstützt:
+ `Number.isFinite`
+ `Number.isNaN`
------
## Integrierte Objekte und Funktionen
Die folgenden Funktionen und Objekte werden unterstützt.
------
#### [ Math ]
Die folgenden mathematischen Funktionen werden unterstützt:
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
Die folgenden Array-Methoden werden unterstützt:
+ `Array.prototype.length`
+ `Array.prototype.concat()`
+ `Array.prototype.fill()`
+ `Array.prototype.flat()`
+ `Array.prototype.indexOf()`
+ `Array.prototype.join()`
+ `Array.prototype.lastIndexOf()`
+ `Array.prototype.pop()`
+ `Array.prototype.push()`
+ `Array.prototype.reverse()`
+ `Array.prototype.shift()`
+ `Array.prototype.slice()`
+ `Array.prototype.sort()`
**Anmerkung**
`Array.prototype.sort()`unterstützt keine Argumente.
+ `Array.prototype.splice()`
+ `Array.prototype.unshift()`
+ `Array.prototype.forEach()`
+ `Array.prototype.map()`
+ `Array.prototype.flatMap()`
+ `Array.prototype.filter()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.find()`
+ `Array.prototype.some()`
+ `Array.prototype.every()`
+ `Array.prototype.findIndex()`
+ `Array.prototype.findLast()`
+ `Array.prototype.findLastIndex()`
+ `delete`
------
#### [ Console ]
Das Konsolenobjekt ist für das Debuggen verfügbar. Während der Live-Abfrageausführung werden log/error Konsolenanweisungen an Amazon CloudWatch Logs gesendet (sofern die Protokollierung aktiviert ist). Während der Codeauswertung mit `evaluateCode` werden Protokollanweisungen in der Befehlsantwort zurückgegeben.
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ Die `call` Methoden `apply``bind`, und werden nicht unterstützt.
+ Funktionskonstruktoren werden nicht unterstützt.
+ Die Übergabe einer Funktion als Argument wird nicht unterstützt.
+ Rekursive Funktionsaufrufen werden nicht unterstützt.
------
#### [ JSON ]
Die folgenden JSON-Methoden werden unterstützt:
+ `JSON.parse()`
**Anmerkung**
Gibt eine leere Zeichenfolge zurück, wenn die analysierte Zeichenfolge kein gültiges JSON ist.
+ `JSON.stringify()`
------
#### [ Promises ]
Asynchrone Prozesse werden nicht unterstützt, und Promises werden nicht unterstützt.
**Anmerkung**
Der Netzwerk- und Dateisystemzugriff wird in der `APPSYNC_JS` Runtime in AWS AppSync nicht unterstützt. AWS AppSync verarbeitet alle I/O-Operationen, die auf den vom AWS AppSync Resolver oder der AWS AppSync Funktion gestellten Anforderungen basieren.
------
## Globale
Die folgenden globalen Konstanten werden unterstützt:
+ `NaN`
+ `Infinity`
+ `undefined`
+ [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html)
+ [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)
+ `runtime`
## Arten von Fehlern
Das Auslösen von Fehlern mit `throw` wird nicht unterstützt. Sie können einen Fehler zurückgeben, indem Sie die `util.error()` Funktion verwenden. Sie können einen Fehler in Ihre GraphQL-Antwort aufnehmen, indem Sie die `util.appendError` Funktion verwenden.
Weitere Informationen finden Sie unter [Error utils](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js).
# Integrierte Dienstprogramme
Die `util` Variable enthält allgemeine Hilfsmethoden, die Ihnen bei der Arbeit mit Daten helfen. Sofern nicht anders angegeben, verwenden alle Dienstprogramme den UTF-8-Zeichensatz.
## Werkzeuge zum Kodieren
### Liste der Kodierungswerkzeuge
**`util.urlEncode(String)`**
Gibt die Eingabezeichenfolge als eine `application/x-www-form-urlencoded`-kodierte Zeichenfolge zurück.
**`util.urlDecode(String)`**
Dekodiert eine `application/x-www-form-urlencoded`-kodierte Zeichenfolge zurück in ihre nicht kodierte Form.
**`util.base64Encode(string) : string`**
Verschlüsselt die Eingabe in eine base64-kodierte Zeichenfolge.
**`util.base64Decode(string) : string`**
Decodiert die Daten einer base64-verschlüsselten Zeichenfolge.
## Dienstprogramme zur ID-Generierung
### Liste der Tools zur ID-Generierung
**`util.autoId()`**
Gibt eine zufällig generierte 128-Bit-UUID zurück.
**`util.autoUlid()`**
Gibt eine zufällig generierte 128-Bit-ULID (Universally Unique Lexicographically Sortable Identifier) zurück.
**`util.autoKsuid()`**
Gibt eine zufällig generierte 128-Bit-KSUID (K-Sortable Unique Identifier) Base62 zurück, die als Zeichenfolge mit einer Länge von 27 codiert ist.
## Fehler utils
### Fehler-Utils-Liste
**`util.error(String, String?, Object?, Object?)`**
Gibt einen benutzerdefinierte Fehler aus. Dies kann in Anforderungs- oder Antwortzuweisungsvorlagen verwendet werden, wenn die Vorlage einen Fehler bei der Anforderung oder beim Aufrufergebnis erkennt. Zusätzlich können ein `errorType` Feld, ein `data` Feld und ein `errorInfo` Feld angegeben werden. Der `data`-Wert wird zum entsprechenden `error`-Block in `errors` in der GraphQL-Antwort hinzugefügt.
`data`wird auf der Grundlage des Abfrageauswahlsatzes gefiltert. Der `errorInfo`-Wert wird zum entsprechenden `error`-Block in `errors` in der GraphQL-Antwort hinzugefügt.
`errorInfo`wird **nicht** auf der Grundlage des Abfrageauswahlsatzes gefiltert.
**`util.appendError(String, String?, Object?, Object?)`**
Fügt einen benutzerdefinierten Fehler an. Dies kann in Anforderungs- oder Antwortzuweisungsvorlagen verwendet werden, wenn die Vorlage einen Fehler bei der Anforderung oder beim Aufrufergebnis erkennt. Zusätzlich können ein `errorType` Feld, ein `data` Feld und ein `errorInfo` Feld angegeben werden. Im Gegensatz zu `util.error(String, String?, Object?, Object?)` wird die Vorlagenbewertung nicht unterbrochen, sodass die Daten an den Aufrufer zurückgegeben werden können. Der `data`-Wert wird zum entsprechenden `error`-Block in `errors` in der GraphQL-Antwort hinzugefügt.
`data`wird auf der Grundlage des Abfrageauswahlsatzes gefiltert. Der `errorInfo`-Wert wird zum entsprechenden `error`-Block in `errors` in der GraphQL-Antwort hinzugefügt.
`errorInfo`wird **nicht** auf der Grundlage des Abfrageauswahlsatzes gefiltert.
## Tools für den Typ- und Musterabgleich
### Liste der Tools für den Typ- und Musterabgleich
**`util.matches(String, String) : Boolean`**
Gibt "true" zurück, wenn das angegebene Muster im ersten Argument den bereitgestellten Daten im zweiten Argument entspricht. Das Muster muss ein regulärer Ausdruck sein, wie z. B. `util.matches("a*b", "aaaaab")`. Die Funktionalität basiert auf [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), worauf Sie zur weiteren Dokumentation verweisen können.
**`util.authType()`**
Gibt eine Zeichenfolge zurück, die den Multi-Auth-Typ beschreibt, der von einer Anfrage verwendet wird, und gibt entweder „IAM-Autorisierung“, „Benutzerpool-Autorisierung“, „Open ID Connect-Autorisierung“ oder „API-Schlüsselautorisierung“ zurück.
## Gibt den Wert zurück, Verhalten, utils
### Liste der Verhaltenswerkzeuge für den Rückgabewert
**`util.escapeJavaScript(String)`**
Gibt die Eingabezeichenfolge als JavaScript Escape-Zeichenfolge zurück.
## Tools zur Autorisierung von Resolver
### Liste der Resolver-Autorisierungswerkzeuge
**`util.unauthorized()`**
Gibt `Unauthorized` für das Feld aus, das aufgelöst wird. Verwenden Sie dies in Vorlagen für die Zuordnung von Anfragen oder Antworten, um zu bestimmen, ob der Anrufer das Feld auflösen darf.
# Integrierten Module
Module sind Teil der `APPSYNC_JS` Runtime und stellen Hilfsprogramme zur Verfügung, mit denen JavaScript Resolver und Funktionen geschrieben werden können. Beispiele und Beispiele finden Sie im [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub Repository.
## Funktionen des DynamoDB-Moduls
DynamoDB-Modulfunktionen bieten eine verbesserte Erfahrung bei der Interaktion mit DynamoDB-Datenquellen. Sie können mithilfe der Funktionen Anfragen an Ihre DynamoDB-Datenquellen stellen, ohne eine Typzuordnung hinzuzufügen.
Module werden wie folgt importiert: `@aws-appsync/utils/dynamodb`
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### Funktionen
#### Funktionsliste
**` get(payload: GetInput): DynamoDBGetItemRequest`**
Informationen [Eingaben](#built-in-ddb-modules-inputs) zu finden Sie unter GetInput.
Generiert ein `DynamoDBGetItemRequest` Objekt, um eine [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)Anfrage an DynamoDB zu stellen.
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
Generiert ein `DynamoDBPutItemRequest` Objekt, um eine [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)Anfrage an DynamoDB zu stellen.
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```
**`remove(payload): DynamoDBDeleteItemRequest`**
Generiert ein `DynamoDBDeleteItemRequest` Objekt, um eine [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)Anfrage an DynamoDB zu stellen.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
Generiert eine`DynamoDBScanRequest`, um eine [Scan-Anfrage](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) an DynamoDB zu stellen.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken } = ctx.args;
return ddb.scan({ limit, nextToken });
}
```
**`sync(payload): DynamoDBSyncRequest`**
Generiert ein `DynamoDBSyncRequest` Objekt, um eine [Sync-Anfrage](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync) zu stellen. Die Anfrage empfängt nur die Daten, die seit der letzten Abfrage geändert wurden (Delta-Updates). Anfragen können nur an versionierte DynamoDB-Datenquellen gestellt werden.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken, lastSync } = ctx.args;
return ddb.sync({ limit, nextToken, lastSync });
}
```
**`update(payload): DynamoDBUpdateItemRequest`**
Generiert ein `DynamoDBUpdateItemRequest` Objekt, um eine [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)Anfrage an DynamoDB zu stellen.
### Operationen
Mithilfe von Operationshelfern können Sie bei Aktualisierungen bestimmte Aktionen für Teile Ihrer Daten ausführen. Importieren Sie zunächst `operations` aus`@aws-appsync/utils/dynamodb`:
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### Liste der Operationen
**`add(payload)`**
Eine Hilfsfunktion, die beim Aktualisieren von DynamoDB ein neues Attributelement hinzufügt.
**Beispiel**
So fügen Sie einem vorhandenen DynamoDB-Element mithilfe des ID-Werts eine Adresse (Straße, Ort und Postleitzahl) hinzu:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
address: operations.add({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`append (payload)`**
Eine Hilfsfunktion, die eine Nutzlast an die bestehende Liste in DynamoDB anhängt.
**Beispiel**
So fügen Sie während eines Updates einen neu hinzugefügten Freund IDs (`newFriendIds`) an eine bestehende Freundesliste (`friendsIds`) an:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.append(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`decrement (by?)`**
Eine Hilfsfunktion, die den vorhandenen Attributwert im Element verringert, wenn DynamoDB aktualisiert wird.
**Beispiel**
Um den Zähler eines Freundes () `friendsCount` um 10 zu verringern:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.decrement(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`increment (by?)`**
Eine Hilfsfunktion, die den vorhandenen Attributwert im Element erhöht, wenn DynamoDB aktualisiert wird.
**Beispiel**
Um den Zähler eines Freundes () `friendsCount` um 10 zu erhöhen:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.increment(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`prepend (payload)`**
Eine Hilfsfunktion, die der vorhandenen Liste in DynamoDB vorangestellt wird.
**Beispiel**
Um einen neu hinzugefügten Freund IDs (`newFriendIds`) während eines Updates einer bestehenden Freundesliste (`friendsIds`) voranzustellen:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.prepend(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`replace (payload)`**
Eine Hilfsfunktion, die ein vorhandenes Attribut ersetzt, wenn ein Element in DynamoDB aktualisiert wird. Dies ist nützlich, wenn Sie das gesamte Objekt oder Unterobjekt im Attribut aktualisieren möchten und nicht nur die Schlüssel in der Nutzlast.
**Beispiel**
Um eine Adresse (Straße, Ort und Postleitzahl) in einem Objekt zu ersetzen: `info`
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
info: {
address: operations.replace({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
},
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`updateListItem (payload, index)`**
Eine Hilfsfunktion, die ein Element in einer Liste ersetzt.
**Beispiel**
Im Rahmen von update (`newFriendIds`) wurden in diesem Beispiel die `updateListItem` ID-Werte des zweiten Elements (index:`1`, neue ID:`102`) und des dritten Elements (index:`2`, neue ID:`112`) in einer Liste (`friendsIds`) aktualisiert.
```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [
ops.updateListItem('102', 1), ops.updateListItem('112', 2)
];
const updateObj = { friendsIds: newFriendIds };
return update({ key: { id: 1 }, update: updateObj });
}
```
### Eingaben
#### Liste der Eingaben
**`Type GetInput`**
```
GetInput: {
consistentRead?: boolean;
key: DynamoDBKey;
}
```
**Deklaration eingeben**
+ `consistentRead?: boolean` (optional)
Ein optionaler boolescher Wert, um anzugeben, ob Sie mit DynamoDB einen stark konsistenten Lesevorgang durchführen möchten.
+ `key: DynamoDBKey` (Erforderlich)
Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben.
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Typ Deklaration**
+ `_version?: number` (optional)
+ `condition?: DynamoDBFilterObject | null` (optional)
Wenn Sie ein Objekt in eine DynamoDB-Tabelle einfügen, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird.
+ `customPartitionKey?: string` (optional)
Wenn diese Option aktiviert ist, ändert dieser Zeichenfolgenwert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Sync-Tabelle verwendet werden, wenn die Versionierung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert.
+ `item: Partial` (Erforderlich)
Die restlichen Attribute des Elements sollen in DynamoDB platziert werden.
+ `key: DynamoDBKey` (Erforderlich)
Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, für das der Put ausgeführt wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben.
+ `populateIndexFields?: boolean` (optional)
Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten und. `gsi_ds_pk` `gsi_ds_sk` Weitere Informationen finden Sie unter [Konflikterkennung und -synchronisierung](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) im *AWS AppSync Entwicklerhandbuch*.
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**Geben Sie Erklärung ein**
+ `query: DynamoDBKeyCondition>` (Erforderlich)
Gibt eine Schlüsselbedingung an, die die abzufragenden Elemente beschreibt. Für einen bestimmten Index sollte die Bedingung für einen Partitionsschlüssel eine Gleichheit und der Sortierschlüssel ein Vergleich oder ein `beginsWith` (wenn es sich um eine Zeichenfolge handelt) sein. Für Partitions- und Sortierschlüssel werden nur Zahlen- und Zeichenfolgentypen unterstützt.
**Beispiel**
Nehmen Sie den folgenden `User` Typ:
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
Die Abfrage kann nur die folgenden Felder enthalten: `id``name`, und`age`:
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Geben Sie Erklärung ein**
+ `_version?: number` (optional)
+ `condition?: DynamoDBFilterObject` (optional)
Wenn Sie ein Objekt in DynamoDB entfernen, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird.
**Beispiel**
Das folgende Beispiel ist ein `DeleteItem` Ausdruck, der eine Bedingung enthält, die es ermöglicht, dass der Vorgang nur dann erfolgreich ist, wenn der Eigentümer des Dokuments mit dem Benutzer übereinstimmt, der die Anfrage gestellt hat.
```
type Task = {
id: string;
title: string;
description: string;
owner: string;
isComplete: boolean;
}
const condition: DynamoDBFilterObject = {
owner: { eq: 'XXXXXXXXXXXXXXXX' },
}
remove({
key: {
id: 'XXXXXXXXXXXXXXXX',
},
condition,
});
```
+ `customPartitionKey?: string` (optional)
Wenn diese Option aktiviert ist, ändert der `customPartitionKey` Wert das Format der `ds_sk` und `ds_pk` -Datensätze, die von der Delta-Synchronisierungstabelle verwendet werden, wenn die Versionsverwaltung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert.
+ `key: DynamoDBKey` (Erforderlich)
Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, das entfernt wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben.
**Beispiel**
Wenn a `User` nur den Hash-Schlüssel mit einem Benutzer hat`id`, würde der Schlüssel wie folgt aussehen:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
Wenn der Tabellenbenutzer einen Hash-Schlüssel (`id`) und einen Sortierschlüssel (`name`) hat, dann würde der Schlüssel so aussehen:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (optional)
Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Sync-Tabelle erstellt, insbesondere in den Spalten `gsi_ds_pk` und`gsi_ds_sk`.
**`Type ScanInput`**
```
ScanInput: {
consistentRead?: boolean | null;
filter?: DynamoDBFilterObject | null;
index?: string | null;
limit?: number | null;
nextToken?: string | null;
scanIndexForward?: boolean | null;
segment?: number;
select?: DynamoDBSelectAttributes;
totalSegments?: number;
}
```
**Deklaration eingeben**
+ `consistentRead?: boolean | null` (optional)
Ein optionaler boolescher Wert zur Angabe konsistenter Lesevorgänge bei der Abfrage von DynamoDB. Der Standardwert ist `false`.
+ `filter?: DynamoDBFilterObject | null` (optional)
Ein optionaler Filter, der auf die Ergebnisse angewendet wird, nachdem sie aus der Tabelle abgerufen wurden.
+ `index?: string | null` (optional)
Ein optionaler Name des zu scannenden Indexes.
+ `limit?: number | null` (optional)
Eine optionale maximale Anzahl von Ergebnissen, die zurückgegeben werden sollen.
+ `nextToken?: string | null` (optional)
Ein optionales Paginierungstoken, um eine vorherige Abfrage fortzusetzen. Dieses wäre von einer vorherigen Abfrage erhalten worden.
+ `scanIndexForward?: boolean | null` (optional)
Ein optionaler boolescher Wert, der angibt, ob die Abfrage in aufsteigender oder absteigender Reihenfolge ausgeführt wird. Standardmäßig ist dieser Wert auf `true` festgelegt.
+ `segment?: number` (optional)
+ `select?: DynamoDBSelectAttributes` (optional)
Von DynamoDB zurückzugebende Attribute. Standardmäßig gibt der AWS AppSync DynamoDB-Resolver nur Attribute zurück, die in den Index projiziert werden. Die unterstützten Werte sind:
+ `ALL_ATTRIBUTES`
Gibt alle Elementattribute aus der angegebenen Tabelle oder dem angegebenen Index zurück. Wenn Sie einen lokalen sekundären Index abfragen, ruft DynamoDB für jedes übereinstimmende Element im Index das gesamte Element aus der übergeordneten Tabelle ab. Wenn der Index konfiguriert ist, um alle Elementattribute zu projizieren, können Sie alle Daten aus dem lokalen sekundären Index erhalten und das Abrufen ist nicht erforderlich.
+ `ALL_PROJECTED_ATTRIBUTES`
Gibt alle Attribute zurück, die in den Index projiziert wurden. Wenn der Index konfiguriert ist, um alle Attribute zu projizieren, entspricht dieser Rückgabewert der Angabe von `ALL_ATTRIBUTES`.
+ `SPECIFIC_ATTRIBUTES`
Gibt nur die in aufgeführten Attribute zurück`ProjectionExpression`. Dieser Rückgabewert entspricht der Angabe `ProjectionExpression` ohne Angabe eines Werts für`AttributesToGet`.
+ `totalSegments?: number` (optional)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**Typ Deklaration**
+ `basePartitionKey?: string` (optional)
Der Partitionsschlüssel der Basistabelle, der bei der Ausführung eines Sync-Vorgangs verwendet werden soll. Dieses Feld ermöglicht die Ausführung eines Synchronisierungsvorgangs, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet.
+ `deltaIndexName?: string` (optional)
Der Index, der für den Sync-Vorgang verwendet wird. Dieser Index ist erforderlich, um einen Sync-Vorgang für die gesamte Delta-Store-Tabelle zu aktivieren, wenn die Tabelle einen benutzerdefinierten Partitionsschlüssel verwendet. Der Synchronisierungsvorgang wird auf der GSI (erstellt am `gsi_ds_pk` und`gsi_ds_sk`) ausgeführt.
+ `filter?: DynamoDBFilterObject | null` (optional)
Ein optionaler Filter, der auf die Ergebnisse angewendet wird, nachdem sie aus der Tabelle abgerufen wurden.
+ `lastSync?: number` (optional)
Der Moment in Epochen-Millisekunden, zu dem der letzte erfolgreiche Synchronisierungsvorgang gestartet wurde. Wenn angegeben, werden nur Elemente zurückgegeben, die sich nach `lastSync` geändert haben. Dieses Feld sollte erst gefüllt werden, nachdem alle Seiten eines ersten Synchronisierungsvorgangs abgerufen wurden. Wenn es weggelassen wird, werden Ergebnisse aus der Basistabelle zurückgegeben. Andernfalls werden Ergebnisse aus der Delta-Tabelle zurückgegeben.
+ `limit?: number | null` (optional)
Eine optionale maximale Anzahl von Elementen, die gleichzeitig ausgewertet werden können. Wenn nicht angegeben, wird das Standardlimit auf `100` Elemente festgelegt. Der maximale Wert für dieses Feld ist `1000` Elemente.
+ `nextToken?: string | null` (optional)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**Geben Sie Erklärung ein**
+ `_version?: number` (optional)
+ `condition?: DynamoDBFilterObject` (optional)
Wenn Sie ein Objekt in DynamoDB aktualisieren, können Sie optional einen bedingten Ausdruck angeben, der steuert, ob die Anforderung erfolgreich sein soll oder nicht, basierend auf dem Zustand des Objekts, das sich bereits in DynamoDB befand, bevor der Vorgang ausgeführt wird.
+ `customPartitionKey?: string` (optional)
Wenn diese Option aktiviert ist, ändert der `customPartitionKey` Wert das Format der `ds_pk` AND-Datensätze, die von der `ds_sk` Delta-Synchronisierungstabelle verwendet werden, wenn die Versionierung aktiviert wurde. Wenn diese Option aktiviert ist, ist auch die Verarbeitung des `populateIndexFields` Eintrags aktiviert.
+ `key: DynamoDBKey` (Erforderlich)
Ein erforderlicher Parameter, der den Schlüssel des Elements in DynamoDB angibt, das aktualisiert wird. DynamoDB-Elemente können einen einzelnen Hashschlüssel oder Hash- und Sortierschlüssel haben.
+ `populateIndexFields?: boolean` (optional)
Ein boolescher Wert, der, wenn er zusammen mit dem aktiviert wird`customPartitionKey`, neue Einträge für jeden Datensatz in der Delta-Synchronisierungstabelle erstellt, insbesondere in den Spalten und. `gsi_ds_pk` `gsi_ds_sk`
+ `update: DynamoDBUpdateObject`
Ein Objekt, das die zu aktualisierenden Attribute zusammen mit den neuen Werten für sie angibt. Das Aktualisierungsobjekt kann mit`add`,,`remove`,`replace`,`increment`,`decrement`, `append``prepend`, verwendet werden`updateListItem`.
## Funktionen des Amazon RDS-Moduls
Die Funktionen des Amazon RDS-Moduls bieten eine verbesserte Benutzererfahrung bei der Interaktion mit Datenbanken, die mit der Amazon RDS-Daten-API konfiguriert sind. Das Modul wird importiert mit`@aws-appsync/utils/rds`:
```
import * as rds from '@aws-appsync/utils/rds';
```
Funktionen können auch einzeln importiert werden. Zum Beispiel verwendet der folgende Import`sql`:
```
import { sql } from '@aws-appsync/utils/rds';
```
### Funktionen
Sie können die Hilfsprogramme des AWS AppSync RDS-Moduls verwenden, um mit Ihrer Datenbank zu interagieren.
#### Select
Das `select` Hilfsprogramm erstellt eine `SELECT` Anweisung zur Abfrage Ihrer relationalen Datenbank.
**Grundlegende Verwendung**
In ihrer Grundform können Sie die Tabelle angeben, die Sie abfragen möchten:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
Beachten Sie, dass Sie das Schema auch in Ihrem Tabellen-Identifier angeben können:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**Spalten angeben**
Sie können Spalten mit der `columns` Eigenschaft angeben. Wenn dieser Wert nicht auf einen Wert gesetzt ist, wird standardmäßig wie folgt vorgegeben`*`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
Sie können auch die Tabelle einer Spalte angeben:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**Grenzwerte und Offsets**
Sie können `limit` und auf `offset` die Abfrage anwenden:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// LIMIT :limit
// OFFSET :offset
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
limit: 10,
offset: 40
}));
}
```
**Sortiert nach**
Sie können Ihre Ergebnisse nach der `orderBy` Eigenschaft sortieren. Geben Sie eine Reihe von Objekten an, die die Spalte und eine optionale `dir` Eigenschaft angeben:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name" FROM "persons"
// ORDER BY "name", "id" DESC
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
}));
}
```
**Filter**
Sie können Filter erstellen, indem Sie das Objekt mit der speziellen Bedingung verwenden:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}}
}));
}
```
Sie können Filter auch kombinieren:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME and "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}, id: {gt: 10}}
}));
}
```
Sie können auch `OR` Aussagen erstellen:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME OR "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { or: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Sie können eine Bedingung auch negieren mit`not`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE NOT ("name" = :NAME AND "id" > :ID)
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { not: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Sie können auch die folgenden Operatoren verwenden, um Werte zu vergleichen:
|
|
| Operator | Description | Mögliche Wertetypen |
| --- |--- |--- |
| eq | Gleich | Zahl, Zeichenfolge, boolescher Wert |
| Eins | Ungleich | Zahl, Zeichenfolge, boolescher Wert |
| le | Kleiner als oder gleich | Zahl, Zeichenfolge |
| lt | Kleiner als | Zahl, Zeichenfolge |
| ge | Größer als oder gleich | Zahl, Zeichenfolge |
| gt | Größer als | Zahl, Zeichenfolge |
| enthält | Wie | Zeichenfolge |
| Nicht enthält | Nicht wie | Zeichenfolge |
| Beginnt mit | Beginnt mit einem Präfix | Zeichenfolge |
| zwischen | Zwischen zwei Werten | Zahl, Zeichenfolge |
| Das Attribut ist vorhanden | Das Attribut ist nicht Null | Zahl, Zeichenfolge, boolescher Wert |
| size | prüft die Länge des Elements | Zeichenfolge |
#### Einfügen
Das `insert` Hilfsprogramm bietet eine einfache Möglichkeit, mit dem `INSERT` Vorgang einzelne Zeilenelemente in Ihre Datenbank einzufügen.
**Einfügungen einzelner Elemente**
Um ein Element einzufügen, geben Sie die Tabelle an und übergeben Sie dann Ihr Werteobjekt. Die Objektschlüssel sind Ihren Tabellenspalten zugeordnet. Spaltennamen werden automatisch maskiert, und Werte werden mithilfe der Variablenzuordnung an die Datenbank gesendet:
```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
return createMySQLStatement(insertStatement)
}
```
**MySQL-Anwendungsfall**
Sie können ein `insert` gefolgt von einem kombinieren`select`, um Ihre eingefügte Zeile abzurufen:
```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
const selectStatement = select({
table: 'persons',
columns: '*',
where: { id: { eq: values.id } },
limit: 1,
});
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
// and
// SELECT *
// FROM `persons`
// WHERE `id` = :ID
return createMySQLStatement(insertStatement, selectStatement)
}
```
**Anwendungsfall Postgres**
Mit Postgres können Sie Daten aus der Zeile abrufen [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html), die Sie eingefügt haben. Es akzeptiert `*` oder ein Array von Spaltennamen:
```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({
table: 'persons',
values,
returning: '*'
});
// Generates statement:
// INSERT INTO "persons"("name")
// VALUES(:NAME)
// RETURNING *
return createPgStatement(insertStatement)
}
```
#### Aktualisierung
Das `update` Tool ermöglicht es Ihnen, bestehende Zeilen zu aktualisieren. Sie können das Bedingungsobjekt verwenden, um Änderungen an den angegebenen Spalten in allen Zeilen vorzunehmen, die die Bedingung erfüllen. Nehmen wir zum Beispiel an, wir haben ein Schema, das es uns ermöglicht, diese Mutation vorzunehmen. Wir wollen das `name` von `Person` mit dem `id` Wert von aktualisieren, `3` aber nur, wenn wir sie (`known_since`) seit dem Jahr kennen`2000`:
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
Unser Update Resolver sieht so aus:
```
import { update, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id, ...values }, condition } = ctx.args;
const where = {
...condition,
id: { eq: id },
};
const updateStatement = update({
table: 'persons',
values,
where,
returning: ['id', 'name'],
});
// Generates statement:
// UPDATE "persons"
// SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
Wir können unserer Bedingung ein Häkchen hinzufügen, um sicherzustellen, dass nur die Zeile aktualisiert `3` wird, deren Primärschlüssel `id` gleich ist. In ähnlicher Weise können Sie Postgres verwenden`inserts`, `returning` um die geänderten Daten zurückzugeben.
#### Remove
Mit dem `remove` Hilfsprogramm können Sie vorhandene Zeilen löschen. Sie können das Bedingungsobjekt für alle Zeilen verwenden, die die Bedingung erfüllen. Beachten Sie, dass `delete` es sich um ein reserviertes Schlüsselwort in handelt JavaScript. `remove`sollte stattdessen verwendet werden:
```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id }, condition } = ctx.args;
const where = { ...condition, id: { eq: id } };
const deleteStatement = remove({
table: 'persons',
where,
returning: ['id', 'name'],
});
// Generates statement:
// DELETE "persons"
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
### Umwandlung
In einigen Fällen benötigen Sie möglicherweise genauere Angaben zum richtigen Objekttyp, den Sie in Ihrer Anweisung verwenden möchten. Sie können die bereitgestellten Typhinweise verwenden, um den Typ Ihrer Parameter anzugeben. AWS AppSync unterstützt [dieselben Typhinweise](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) wie die Daten-API. Sie können Ihre Parameter mithilfe der `typeHint` Funktionen des AWS AppSync `rds` Moduls umwandeln.
Das folgende Beispiel ermöglicht es Ihnen, ein Array als Wert zu senden, der als JSON-Objekt umgewandelt wird. Wir verwenden den `->` Operator, um das Element `index` `2` im JSON-Array abzurufen:
```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const arr = ctx.args.list_of_ids
const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
return createPgStatement(statement)
}
export function response(ctx) {
return toJsonObject(ctx.result)[0][0].value
}
```
Casting ist auch nützlich bei der Handhabung und beim Vergleichen von `DATE``TIME`, und`TIMESTAMP`:
```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const when = ctx.args.when
const statement = select({
table: 'persons',
where: { createdAt : { gt: typeHint.DATETIME(when) } }
})
return createPgStatement(statement)
}
```
Hier ist ein weiteres Beispiel, das zeigt, wie Sie das aktuelle Datum und die aktuelle Uhrzeit senden können:
```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```
**Verfügbare Typhinweise**
+ `typeHint.DATE`- Der entsprechende Parameter wird als Objekt des `DATE` Typs an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD`.
+ `typeHint.DECIMAL`- Der entsprechende Parameter wird als Objekt des `DECIMAL` Typs an die Datenbank gesendet.
+ `typeHint.JSON`- Der entsprechende Parameter wird als Objekt des `JSON` Typs an die Datenbank gesendet.
+ `typeHint.TIME`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `TIME` Typs an die Datenbank gesendet. Das akzeptierte Format ist `HH:MM:SS[.FFF]`.
+ `typeHint.TIMESTAMP`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `TIMESTAMP` Typs an die Datenbank gesendet. Das akzeptierte Format ist `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `typeHint.UUID`- Der entsprechende Zeichenkettenparameterwert wird als Objekt des `UUID` Typs an die Datenbank gesendet.
# Laufzeit-Dienstprogramme
Die `runtime` Bibliothek stellt Dienstprogramme zur Verfügung, mit denen Sie die Laufzeiteigenschaften Ihrer Resolver und Funktionen steuern oder ändern können.
## Liste der Runtime-Utils
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
Wenn Sie diese Funktion aufrufen, wird die Ausführung des aktuellen Handlers, der AWS AppSync Funktion oder des Resolvers (Unit- oder Pipeline-Resolver) je nach aktuellem Kontext angehalten. Das angegebene Objekt wird als Ergebnis zurückgegeben.
+ Beim Aufruf in einem AWS AppSync Funktionsanforderungshandler werden die Datenquelle und der Antworthandler übersprungen, und der nächste Funktionsanforderungshandler (oder der Antworthandler des Pipeline-Resolvers, falls dies die letzte AWS AppSync Funktion war) wird aufgerufen.
+ Beim Aufruf in einem AWS AppSync Pipeline-Resolver-Anforderungshandler wird die Pipeline-Ausführung übersprungen und der Pipeline-Resolver-Response-Handler wird sofort aufgerufen.
+ Wenn angegeben und der Wert auf „END“ `skipTo` gesetzt `returnOptions` ist, wird die Pipeline-Ausführung übersprungen und der Response-Handler für den Pipeline-Resolver wird sofort aufgerufen.
+ Wenn angegeben und auf „NEXT“ `skipTo` gesetzt `returnOptions` ist, wird die Funktionsausführung übersprungen und der nächste Pipeline-Handler aufgerufen.
**Beispiel**
```
import { runtime } from '@aws-appsync/utils'
export function request(ctx) {
runtime.earlyReturn({ hello: 'world' })
// code below is not executed
return ctx.args
}
// never called because request returned early
export function response(ctx) {
return ctx.result
}
```
# Zeithelfer in util.time
Die `util.time`-Variable enthält "datetime"-Methoden, um beim Generieren von Zeitstempeln, Konvertieren zwischen "datetime"-Formaten und Parsen von "datetime"-Zeichenfolgen zu helfen. Die Syntax für Datetime-Formate basiert auf dieser Syntax [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), auf die Sie für weitere Dokumentation verweisen können.
## Liste der Time-Utils
**`util.time.nowISO8601()`**
Gibt eine String-Darstellung von UTC im [ISO8601Format](https://en.wikipedia.org/wiki/ISO_8601) zurück.
**`util.time.nowEpochSeconds()`**
Gibt die Anzahl der Sekunden aus der Epoche von 1970-01-01T00:00:00Z bis jetzt zurück.
**`util.time.nowEpochMilliSeconds()`**
Gibt die Anzahl der Millisekunden aus der Epoche von 1970-01-01T00:00:00Z bis jetzt zurück.
**`util.time.nowFormatted(String)`**
Gibt eine Zeichenfolge des aktuellen Zeitstempels in UTC unter Verwendung des angegebenen Formats aus einem Zeichenfolge-Eingabetyp zurück.
**`util.time.nowFormatted(String, String)`**
Gibt eine Zeichenfolge des aktuellen Zeitstempels aus einer Zeitzone unter Verwendung des angegebenen Formats und der Zeitzone aus Zeichenfolge-Eingabetypen zurück.
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
Analysiert einen als String übergebenen Zeitstempel zusammen mit einem Format, das eine Zeitzone enthält, und gibt dann den Zeitstempel in Millisekunden seit der Epoche zurück.
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
Analysiert einen als String übergebenen Zeitstempel zusammen mit einem Format und einer Zeitzone und gibt dann den Zeitstempel in Millisekunden seit der Epoche zurück.
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
Analysiert einen als String übergebenen Zeitstempel und gibt dann den ISO8601 Zeitstempel in Millisekunden seit der Epoche zurück.
**`util.time.epochMilliSecondsToSeconds(long)`**
Konvertiert einen Epoche-Millisekunden-Zeitstempel in einen Epoche-Sekunden-Zeitstempel.
**`util.time.epochMilliSecondsToISO8601(long)`**
Konvertiert einen Millisekunden-Zeitstempel einer Epoche in einen Zeitstempel. ISO8601
**`util.time.epochMilliSecondsToFormatted(long, String)`**
Konvertiert einen Epochen-Millisekunden-Zeitstempel, der als long übergeben wurde, in einen Zeitstempel, der gemäß dem angegebenen Format in UTC formatiert ist.
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
Konvertiert einen Epochen-Millisekunden-Zeitstempel, der als Long übergeben wurde, in einen Zeitstempel, der gemäß dem angegebenen Format in der angegebenen Zeitzone formatiert ist.
# DynamoDB-Helfer in util.dynamodb
`util.dynamodb`enthält Hilfsmethoden, die das Schreiben und Lesen von Daten in Amazon DynamoDB erleichtern, z. B. automatische Typzuweisung und Formatierung.
## Zu DynamoDB
### Liste der ToDynamoDB-Dienstprogramme
**`util.dynamodb.toDynamoDB(Object)`**
Allgemeines Objektkonvertierungstool für DynamoDB, das Eingabeobjekte in die entsprechende DynamoDB-Darstellung konvertiert. Es ist vorbestimmt, wie einige Typen dargestellt werden: z. B. werden Listen ("L") anstelle von Sätzen ("SS", "NS", "BS") verwendet. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
**Beispiel für eine Zeichenfolge**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**Beispiel für eine Zahl**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**Boolesches Beispiel**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**Beispiel auflisten**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**Beispiel für eine Karte**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## ToString-Dienstprogramme
### Liste der ToString-Dienstprogramme
**`util.dynamodb.toString(String)`**
Konvertiert eine Eingabezeichenfolge in das DynamoDB-Zeichenkettenformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
Konvertiert eine Liste mit Strings in das DynamoDB-Zeichenkettensatzformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## ToNumber-Dienstprogramme
### Liste der ToNumber-Dienstprogramme
**`util.dynamodb.toNumber(Number)`**
Konvertiert eine Zahl in das DynamoDB-Zahlenformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
Konvertiert eine Liste von Zahlen in das DynamoDB-Nummernsatzformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## ToBinary-Dienstprogramme
### Liste der ToBinary-Dienstprogramme
**`util.dynamodb.toBinary(String)`**
Konvertiert als Base64-Zeichenfolge kodierte Binärdaten in das DynamoDB-Binärformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
Konvertiert eine Liste von Binärdaten, die als Base64-Zeichenfolgen kodiert sind, in das DynamoDB-Binärsatzformat. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## ToBoolesche Hilfsprogramme
### Liste der toBooleschen Dienstprogramme
**`util.dynamodb.toBoolean(Boolean)`**
Konvertiert einen booleschen Wert in das entsprechende boolesche DynamoDB-Format. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## ToNull Utils
### ToNull-Utils-Liste
**`util.dynamodb.toNull()`**
Gibt eine Null im DynamoDB-Null-Format zurück. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## ToList-Dienstprogramme
### Liste der ToList-Dienstprogramme
**`util.dynamodb.toList(List)`**
Konvertiert eine Liste von Objekten in das DynamoDB-Listenformat. Jedes Element in der Liste wird auch in das entsprechende DynamoDB-Format konvertiert. Es ist vorbestimmt, wie einige verschachtelte Objekte dargestellt werden: z. B. werden Listen ("L") anstelle von Sätzen ("SS", "NS", "BS") verwendet. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## ToMap-Dienstprogramme
### Liste der ToMap-Dienstprogramme
**`util.dynamodb.toMap(Map)`**
Konvertiert eine Map in das DynamoDB-Kartenformat. Jeder Wert in der Map wird ebenfalls in das entsprechende DynamoDB-Format konvertiert. Es ist vorbestimmt, wie einige verschachtelte Objekte dargestellt werden: z. B. werden Listen ("L") anstelle von Sätzen ("SS", "NS", "BS") verwendet. Dies gibt ein Objekt zurück, das den DynamoDB-Attributwert beschreibt.
```
Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
**`util.dynamodb.toMapValues(Map)`**
Erstellt eine Kopie der Map, in der jeder Wert in das entsprechende DynamoDB-Format konvertiert wurde. Es ist vorbestimmt, wie einige verschachtelte Objekte dargestellt werden: z. B. werden Listen ("L") anstelle von Sätzen ("SS", "NS", "BS") verwendet.
```
Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
```
Dies unterscheidet sich `util.dynamodb.toMap(Map)` geringfügig davon, dass nur der Inhalt des DynamoDB-Attributwerts zurückgegeben wird, nicht jedoch der gesamte Attributwert selbst. Die folgenden Aussagen sind beispielsweise identisch:
```
util.dynamodb.toMapValues(