As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# AWS AppSync JavaScript referência da função de resolução para Lambda
Você pode usar AWS AppSync funções e resolvedores para invocar funções do Lambda localizadas em sua conta. Você pode moldar suas cargas úteis de solicitação e a resposta de suas funções do Lambda antes de devolvê-las aos seus clientes. Também é possível especificar o tipo de operação a ser executada no seu objeto de solicitação. Esta seção descreve as solicitações para operações Lambda compatíveis.
## Objeto de solicitação
O objeto de solicitação do Lambda manipula campos relacionados à sua função do Lambda:
```
export type LambdaRequest = {
operation: 'Invoke' | 'BatchInvoke';
invocationType?: 'RequestResponse' | 'Event';
payload: unknown;
};
```
Aqui está um exemplo que usa uma operação `invoke` com seus dados de carga útil sendo o campo `getPost` de um esquema GraphQL junto com seus argumentos do contexto:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Todo o documento de mapeamento é passado como entrada para sua função do Lambda, assim o exemplo anterior agora tem esta aparência:
```
{
"operation": "Invoke",
"payload": {
"field": "getPost",
"arguments": {
"input": {
"id": "postId1",
}
}
}
}
```
### Operation
A fonte de dados do Lambda permite que você defina duas operações no campo `operation`: `Invoke` e `BatchInvoke`. A `Invoke` operação permite AWS AppSync que você chame sua função Lambda para cada resolvedor de campo do GraphQL. `BatchInvoke`instrui as solicitações em lote AWS AppSync para o campo GraphQL atual. O campo `operation` é obrigatório.
Para `Invoke`, a solicitação resolvida corresponde à carga útil de entrada da função do Lambda. Vamos modificar o exemplo acima:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Isso é resolvido e passado para a função do Lambda, que poderá ser mais ou menos assim:
```
{
"operation": "Invoke",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Para `BatchInvoke`, a solicitação é aplicada a cada resolvedor de campo no lote. Para ser conciso, AWS AppSync mescla todos os `payload` valores da solicitação em uma lista sob um único objeto correspondente ao objeto da solicitação. Veja um exemplo de mesclagem pelo manipulador de solicitação:
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: ctx,
};
}
```
Essa solicitação é avaliada e resolvida no seguinte documento de mapeamento:
```
{
"operation": "BatchInvoke",
"payload": [
{...}, // context for batch item 1
{...}, // context for batch item 2
{...} // context for batch item 3
]
}
```
Cada elemento da lista `payload` corresponde a um único item de lote. Também se espera que a função do Lambda retorne uma resposta em forma de lista correspondente à ordem dos itens enviados na solicitação:
```
[
{ "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
]
```
### Carga útil
O campo `payload` é um contêiner usado para passar quaisquer dados para a função do Lambda. Se o `operation` campo estiver definido como`BatchInvoke`, AWS AppSync agrupa os `payload` valores existentes em uma lista. O campo `payload` é opcional.
### Tipo de invocação
A fonte de dados do Lambda permite que você defina dois tipos de invocação: `RequestResponse` e `Event`. Os tipos de invocação são sinônimos dos tipos de invocação definidos na [API do Lambda](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html). O tipo de `RequestResponse` invocação permite AWS AppSync chamar sua função Lambda de forma síncrona para aguardar uma resposta. A invocação `Event` permite que você invoque sua função do Lambda de forma assíncrona. Para obter mais informações sobre como o Lambda lida com solicitações de tipo de invocação `Event`, consulte [Invocação assíncrona](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html). O campo `invocationType` é opcional. Se esse campo não for incluído na solicitação, o padrão AWS AppSync será o tipo de `RequestResponse` invocação.
Para qualquer campo `invocationType`, a solicitação resolvida corresponde à carga útil de entrada da função do Lambda. Vamos modificar o exemplo acima:
```
export function request(ctx) {
return {
operation: 'Invoke',
invocationType: 'Event',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Isso é resolvido e passado para a função do Lambda, que poderá ser mais ou menos assim:
```
{
"operation": "Invoke",
"invocationType": "Event",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Quando a `BatchInvoke` operação é usada em conjunto com o campo do tipo de `Event` invocação, AWS AppSync mescla o resolvedor de campo da mesma forma mencionada acima, e a solicitação é passada para sua função Lambda como um evento assíncrono, sendo uma lista de valores. `payload` A resposta de uma solicitação do tipo de invocação `Event` resulta em um valor `null` sem um manipulador de resposta:
```
{
"data": {
"field": null
}
}
```
Recomendamos que você desative o cache do resolvedor para resolvedores do tipo de invocação `Event`, pois eles não seriam enviados ao Lambda se houvesse um acerto do cache.
## Objeto da resposta
Assim como em outras fontes de dados, sua função Lambda envia uma resposta AWS AppSync que deve ser convertida em um tipo GraphQL. O resultado da função do Lambda é contido na propriedade de resultado `context` (`context.result`).
Se a forma da resposta da função do Lambda corresponder à forma do tipo do GraphQL, você pode encaminhar a resposta usando o seguinte manipulador de função da resposta:
```
export function response(ctx) {
return ctx.result
}
```
Não existem campos obrigatórios ou restrições de forma que se aplicam ao objeto de retorno. No entanto, como o GraphQL tem vários tipos, a resposta resolvida deve corresponder ao tipo do GraphQL esperado.
## Resposta em lote da função do Lambda
Se o campo `operation` estiver definido como `BatchInvoke`, o AWS AppSync espera de volta uma lista de itens da função do Lambda. Para AWS AppSync mapear cada resultado de volta ao item da solicitação original, a lista de respostas deve corresponder em tamanho e ordem. É válido ter itens `null` na lista de respostas; `ctx.result` será adequadamente definido como *nulo*.