Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# AWS AppSync JavaScript riferimento alla funzione resolver per Lambda
Puoi usare AWS AppSync funzioni e resolver per richiamare le funzioni Lambda presenti nel tuo account. Puoi modellare i payload della richiesta e la risposta delle tue funzioni Lambda prima di restituirli ai tuoi clienti. Puoi anche specificare il tipo di operazione da eseguire nell'oggetto della richiesta. Questa sezione descrive le richieste per le operazioni Lambda supportate.
## Oggetto Request
L'oggetto di richiesta Lambda gestisce i campi relativi alla tua funzione Lambda:
```
export type LambdaRequest = {
operation: 'Invoke' | 'BatchInvoke';
invocationType?: 'RequestResponse' | 'Event';
payload: unknown;
};
```
Ecco un esempio che utilizza un'`invoke`operazione i cui dati di payload sono il `getPost` campo di uno schema GraphQL insieme ai suoi argomenti dal contesto:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
L'intero documento di mappatura viene passato come input alla funzione Lambda in modo che l'esempio precedente abbia ora il seguente aspetto:
```
{
"operation": "Invoke",
"payload": {
"field": "getPost",
"arguments": {
"input": {
"id": "postId1",
}
}
}
}
```
### Operation
L'origine dati Lambda consente di definire due operazioni sul `operation` campo: `Invoke` e. `BatchInvoke` L'`Invoke`operazione consente di AWS AppSync sapere di chiamare la funzione Lambda per ogni resolver di campi GraphQL. `BatchInvoke`indica di eseguire AWS AppSync in batch le richieste per il campo GraphQL corrente. Il campo `operation` è obbligatorio.
Infatti`Invoke`, la richiesta risolta corrisponde al payload di input della funzione Lambda. Modifichiamo l'esempio precedente:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Questo problema viene risolto e passato alla funzione Lambda, che potrebbe assomigliare a questa:
```
{
"operation": "Invoke",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Infatti`BatchInvoke`, la richiesta viene applicata a tutti i risolutori di campo del batch. Per motivi di concisione, AWS AppSync unisce tutti i `payload` valori della richiesta in un elenco sotto un singolo oggetto corrispondente all'oggetto della richiesta. Il seguente gestore di richieste di esempio mostra l'unione:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: ctx,
};
}
```
Questa richiesta viene valutata e risolta nel seguente documento di mappatura:
```
{
"operation": "BatchInvoke",
"payload": [
{...}, // context for batch item 1
{...}, // context for batch item 2
{...} // context for batch item 3
]
}
```
Ogni elemento dell'`payload`elenco corrisponde a un singolo elemento del batch. Si prevede inoltre che la funzione Lambda restituisca una risposta a forma di elenco corrispondente all'ordine degli elementi inviati nella richiesta:
```
[
{ "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
]
```
### Carico utile
Il `payload` campo è un contenitore utilizzato per passare qualsiasi dato alla funzione Lambda. Se il `operation` campo è impostato su`BatchInvoke`, AWS AppSync racchiude i `payload` valori esistenti in un elenco. Il campo `payload` è facoltativo.
### Tipo di invocazione
L'origine dati Lambda consente di definire due tipi di invocazione: e. `RequestResponse` `Event` [I tipi di invocazione sono sinonimi dei tipi di invocazione definiti nell'API Lambda.](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html) Il tipo di `RequestResponse` invocazione consente di AWS AppSync chiamare la funzione Lambda in modo sincrono per attendere una risposta. L'`Event`invocazione consente di richiamare la funzione Lambda in modo asincrono. [Per ulteriori informazioni su come Lambda gestisce le richieste dei tipi di `Event` invocazione, consulta Invocazione asincrona.](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) Il campo `invocationType` è facoltativo. Se questo campo non è incluso nella richiesta, verrà utilizzato per impostazione predefinita il tipo di invocazione. AWS AppSync `RequestResponse`
Per qualsiasi `invocationType` campo, la richiesta risolta corrisponde al payload di input della funzione Lambda. Modifichiamo l'esempio precedente:
```
export function request(ctx) {
return {
operation: 'Invoke',
invocationType: 'Event',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Questo problema viene risolto e passato alla funzione Lambda, che potrebbe assomigliare a questa:
```
{
"operation": "Invoke",
"invocationType": "Event",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Quando l'`BatchInvoke`operazione viene utilizzata insieme al campo del tipo di `Event` invocazione, AWS AppSync unisce il resolver di campo nello stesso modo menzionato sopra e la richiesta viene passata alla funzione Lambda come evento asincrono costituito da un elenco di valori. `payload` La risposta di una richiesta di tipo di `Event` invocazione restituisce un valore senza un gestore di risposta: `null`
```
{
"data": {
"field": null
}
}
```
Ti consigliamo di disabilitare la memorizzazione nella cache dei resolver per i resolver di tipo di `Event` invocazione perché questi non verrebbero inviati a Lambda se si verificasse un problema nella cache.
## Oggetto Response
Come con altre fonti di dati, la funzione Lambda invia una risposta a AWS AppSync che deve essere convertita in un tipo GraphQL. Il risultato della funzione Lambda è contenuto nella proprietà `context` result ()`context.result`.
Se la forma della risposta della funzione Lambda corrisponde alla forma del tipo GraphQL, puoi inoltrare la risposta utilizzando il seguente gestore di risposte alla funzione:
```
export function response(ctx) {
return ctx.result
}
```
Non ci sono campi obbligatori o restrizioni di forma che si applicano all'oggetto di risposta. Tuttavia, poiché GraphQL è fortemente tipizzato, la risposta risolta deve corrispondere al tipo GraphQL previsto.
## Risposta in batch della funzione Lambda
Se il campo `operation` è impostato su `BatchInvoke`, AWS AppSync si aspetta che la funzione Lambda restituisca un elenco di voci. Per riportare ogni risultato AWS AppSync all'elemento della richiesta originale, l'elenco delle risposte deve corrispondere per dimensioni e ordine. È valido avere `null` elementi nell'elenco delle risposte; `ctx.result` è impostato di conseguenza su *null*.