Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# AWS AppSync JavaScript Resolver-Funktionsreferenz für Lambda
Sie können AWS AppSync Funktionen und Resolver verwenden, um Lambda-Funktionen in Ihrem Konto aufzurufen. Sie können Ihre Anforderungs-Payloads und die Antwort Ihrer Lambda-Funktionen gestalten, bevor Sie sie an Ihre Clients zurückgeben. Sie können auch die Art der Operation angeben, die in Ihrem Anforderungsobjekt ausgeführt werden soll. In diesem Abschnitt werden die Anfragen für die unterstützten Lambda-Operationen beschrieben.
## Objekt anfordern
Das Lambda-Anforderungsobjekt verarbeitet Felder, die sich auf Ihre Lambda-Funktion beziehen:
```
export type LambdaRequest = {
operation: 'Invoke' | 'BatchInvoke';
invocationType?: 'RequestResponse' | 'Event';
payload: unknown;
};
```
Hier ist ein Beispiel, das eine `invoke` Operation verwendet, deren Nutzdaten das `getPost` Feld aus einem GraphQL-Schema zusammen mit den Argumenten aus dem Kontext sind:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Das gesamte Mapping-Dokument wird als Eingabe für Ihre Lambda-Funktion übergeben, sodass das vorherige Beispiel nun wie folgt aussieht:
```
{
"operation": "Invoke",
"payload": {
"field": "getPost",
"arguments": {
"input": {
"id": "postId1",
}
}
}
}
```
### Operation
Mit der Lambda-Datenquelle können Sie zwei Operationen im `operation` Feld definieren: `Invoke` und`BatchInvoke`. Die `Invoke` Operation teilt mit AWS AppSync , dass Sie Ihre Lambda-Funktion für jeden GraphQL-Feldresolver aufrufen sollen. `BatchInvoke`weist AWS AppSync an, Anfragen für das aktuelle GraphQL-Feld zu stapeln. Das Feld `operation` ist ein Pflichtfeld.
Denn `Invoke` die aufgelöste Anfrage entspricht der Eingabe-Payload der Lambda-Funktion. Lassen Sie uns das obige Beispiel ändern:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Dies wird gelöst und an die Lambda-Funktion übergeben, die etwa so aussehen könnte:
```
{
"operation": "Invoke",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Denn `BatchInvoke` die Anfrage wird auf jeden Field Resolver im Batch angewendet. Führt aus Gründen der Übersichtlichkeit alle `payload` Anforderungswerte zu einer Liste unter einem einzigen Objekt zusammen, das dem Anforderungsobjekt entspricht. AWS AppSync Der folgende Beispiel-Request-Handler zeigt die Zusammenführung:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: ctx,
};
}
```
Diese Anfrage wird ausgewertet und im folgenden Mapping-Dokument aufgelöst:
```
{
"operation": "BatchInvoke",
"payload": [
{...}, // context for batch item 1
{...}, // context for batch item 2
{...} // context for batch item 3
]
}
```
Jedes Element der `payload` Liste entspricht einem einzelnen Batch-Element. Es wird auch erwartet, dass die Lambda-Funktion eine listenförmige Antwort zurückgibt, die der Reihenfolge der in der Anfrage gesendeten Elemente entspricht:
```
[
{ "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 1
{ "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 2
{ "data": {...}, "errorMessage": null, "errorType": null } // result for batch item 3
]
```
### Nutzlast
Das `payload` Feld ist ein Container, der verwendet wird, um Daten an die Lambda-Funktion zu übergeben. Wenn das `operation` Feld auf gesetzt ist`BatchInvoke`, werden AWS AppSync die vorhandenen `payload` Werte in eine Liste zusammengefasst. Das Feld `payload` ist optional.
### Aufruftyp
Mit der Lambda-Datenquelle können Sie zwei Aufruftypen definieren: `RequestResponse` und. `Event` [Die Aufruftypen sind synonym mit den in der Lambda-API definierten Aufruftypen.](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html) Mit dem `RequestResponse` AWS AppSync Aufruftyp können Sie Ihre Lambda-Funktion synchron aufrufen, um auf eine Antwort zu warten. Der `Event` Aufruf ermöglicht es Ihnen, Ihre Lambda-Funktion asynchron aufzurufen. Weitere Informationen darüber, wie Lambda Anfragen vom `Event` Aufruftyp verarbeitet, finden Sie unter [Asynchroner](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) Aufruf. Das Feld `invocationType` ist optional. Wenn dieses Feld nicht in der Anfrage enthalten ist, AWS AppSync wird standardmäßig der Aufruftyp verwendet. `RequestResponse`
Für jedes `invocationType` Feld entspricht die aufgelöste Anfrage der Eingabe-Payload der Lambda-Funktion. Lassen Sie uns das obige Beispiel ändern:
```
export function request(ctx) {
return {
operation: 'Invoke',
invocationType: 'Event',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Dies wird gelöst und an die Lambda-Funktion übergeben, die etwa so aussehen könnte:
```
{
"operation": "Invoke",
"invocationType": "Event",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Wenn der `BatchInvoke` Vorgang in Verbindung mit dem `Event` Aufruftypfeld verwendet wird, AWS AppSync führt er den Feldauflöser auf die oben beschriebene Weise zusammen, und die Anforderung wird als asynchrones Ereignis an Ihre Lambda-Funktion übergeben, `payload` wobei es sich um eine Werteliste handelt. Die Antwort auf eine Anfrage vom `Event` Aufruftyp führt zu einem `null` Wert ohne Antworthandler:
```
{
"data": {
"field": null
}
}
```
Wir empfehlen, das Resolver-Caching für Resolver vom `Event` Aufruftyp zu deaktivieren, da diese bei einem Cache-Treffer nicht an Lambda gesendet würden.
## Antwortobjekt
Wie bei anderen Datenquellen sendet Ihre Lambda-Funktion eine Antwort darauf AWS AppSync , die in einen GraphQL-Typ konvertiert werden muss. Das Ergebnis der Lambda-Funktion ist in der `context` Ergebniseigenschaft (`context.result`) enthalten.
Wenn die Form Ihrer Lambda-Funktionsantwort mit der Form des GraphQL-Typs übereinstimmt, können Sie die Antwort mit dem folgenden Funktionsantwort-Handler weiterleiten:
```
export function response(ctx) {
return ctx.result
}
```
Es gibt keine erforderlichen Felder oder Formbeschränkungen, die für das Antwortobjekt gelten. Da GraphQL jedoch stark typisiert ist, muss die aufgelöste Antwort dem erwarteten GraphQL-Typ entsprechen.
## Batch-Antwort mit Lambda-Funktion
Wenn das `operation`-Feld auf `BatchInvoke` festgelegt ist, erwartet AWS AppSync eine Liste mit Elementen aus der Lambda-Funktion. Damit jedes Ergebnis AWS AppSync dem ursprünglichen Anforderungselement zugeordnet werden kann, muss die Antwortliste in Größe und Reihenfolge übereinstimmen. Es ist zulässig, `null` Elemente in der Antwortliste zu haben; sie `ctx.result` wird entsprechend auf *Null* gesetzt.