Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS AppSync JavaScript référence de la fonction de résolution pour Lambda
Vous pouvez utiliser des AWS AppSync fonctions et des résolveurs pour appeler les fonctions Lambda situées dans votre compte. Vous pouvez façonner les charges utiles de vos demandes et la réponse de vos fonctions Lambda avant de les renvoyer à vos clients. Vous pouvez également spécifier le type d'opération à effectuer dans votre objet de demande. Cette section décrit les demandes relatives aux opérations Lambda prises en charge.
## Objet Requête
L'objet de requête Lambda gère les champs liés à votre fonction Lambda :
```
export type LambdaRequest = {
operation: 'Invoke' | 'BatchInvoke';
invocationType?: 'RequestResponse' | 'Event';
payload: unknown;
};
```
Voici un exemple qui utilise une `invoke` opération dont les données de charge utile sont le `getPost` champ d'un schéma GraphQL avec ses arguments issus du contexte :
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
L'intégralité du document de mappage est transmise en entrée à votre fonction Lambda, de sorte que l'exemple précédent ressemble désormais à ceci :
```
{
"operation": "Invoke",
"payload": {
"field": "getPost",
"arguments": {
"input": {
"id": "postId1",
}
}
}
}
```
### Opération
La source de données Lambda vous permet de définir deux opérations `operation` sur le terrain : `Invoke` et. `BatchInvoke` L'`Invoke`opération permet de AWS AppSync savoir d'appeler votre fonction Lambda pour chaque résolveur de champs GraphQL. `BatchInvoke`indique de regrouper AWS AppSync les requêtes pour le champ GraphQL actuel. Le champ `operation` est obligatoire.
En effet`Invoke`, la demande résolue correspond à la charge utile d'entrée de la fonction Lambda. Modifions l'exemple ci-dessus :
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Ceci est résolu et transmis à la fonction Lambda, qui pourrait ressembler à ceci :
```
{
"operation": "Invoke",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
En `BatchInvoke` effet, la demande est appliquée à chaque résolveur de champs du lot. Par souci de concision, AWS AppSync fusionne toutes les `payload` valeurs de demande dans une liste sous un seul objet correspondant à l'objet de la demande. L'exemple de gestionnaire de demandes suivant illustre la fusion :
```
export function request(ctx) {
return {
operation: 'Invoke',
payload: ctx,
};
}
```
Cette demande est évaluée et résolue dans le document de mappage suivant :
```
{
"operation": "BatchInvoke",
"payload": [
{...}, // context for batch item 1
{...}, // context for batch item 2
{...} // context for batch item 3
]
}
```
Chaque élément de la `payload` liste correspond à un seul article du lot. La fonction Lambda devrait également renvoyer une réponse sous forme de liste correspondant à l'ordre des éléments envoyés dans la demande :
```
[
{ "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
]
```
### Charge utile
Le `payload` champ est un conteneur utilisé pour transmettre des données à la fonction Lambda. Si le `operation` champ est défini sur`BatchInvoke`, AWS AppSync regroupe les `payload` valeurs existantes dans une liste. Le champ `payload` est facultatif.
### Types d’invocation
La source de données Lambda vous permet de définir deux types d'invocation : et. `RequestResponse` `Event` [Les types d'invocation sont synonymes des types d'invocation définis dans l'API Lambda.](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html) Le type `RequestResponse` d'invocation permet d' AWS AppSync appeler votre fonction Lambda de manière synchrone pour attendre une réponse. L'`Event`invocation vous permet d'appeler votre fonction Lambda de manière asynchrone. [Pour plus d'informations sur la façon dont Lambda gère les demandes de type `Event` invocation, consultez Invocation asynchrone.](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) Le champ `invocationType` est facultatif. Si ce champ n'est pas inclus dans la demande, le type d'`RequestResponse`appel AWS AppSync sera défini par défaut.
Quel que soit `invocationType` le champ, la demande résolue correspond à la charge utile d'entrée de la fonction Lambda. Modifions l'exemple ci-dessus :
```
export function request(ctx) {
return {
operation: 'Invoke',
invocationType: 'Event',
payload: { field: 'getPost', arguments: ctx.args },
};
}
```
Ceci est résolu et transmis à la fonction Lambda, qui pourrait ressembler à ceci :
```
{
"operation": "Invoke",
"invocationType": "Event",
"payload": {
"arguments": {
"id": "postId1"
}
}
}
```
Lorsque l'`BatchInvoke`opération est utilisée conjointement avec le champ de type d'`Event`appel, elle AWS AppSync fusionne le résolveur de champ de la même manière que celle mentionnée ci-dessus, et la demande est transmise à votre fonction Lambda sous forme d'événement asynchrone sous la forme d'une liste de valeurs. `payload` La réponse d'une demande de type `Event` invocation aboutit à une `null` valeur sans gestionnaire de réponse :
```
{
"data": {
"field": null
}
}
```
Nous vous recommandons de désactiver la mise en cache des résolveurs pour les résolveurs de type `Event` invocation, car ceux-ci ne seraient pas envoyés à Lambda en cas d'accès au cache.
## Objet Réponse
Comme pour les autres sources de données, votre fonction Lambda envoie une réponse AWS AppSync qui doit être convertie en un type GraphQL. Le résultat de la fonction Lambda est contenu dans la propriété de `context` résultat ()`context.result`.
Si la forme de la réponse de votre fonction Lambda correspond à la forme du type GraphQL, vous pouvez transférer la réponse à l'aide du gestionnaire de réponse de fonction suivant :
```
export function response(ctx) {
return ctx.result
}
```
Aucun champ obligatoire ni aucune restriction de forme ne s'appliquent à l'objet de réponse. Cependant, comme GraphQL est fortement typé, la réponse résolue doit correspondre au type GraphQL attendu.
## Réponse par lots de la fonction Lambda
Si le champ `operation` est défini sur `BatchInvoke`, AWS AppSync attend une liste d'éléments renvoyée par la fonction Lambda. Afin de AWS AppSync faire correspondre chaque résultat à l'élément de demande d'origine, la liste de réponses doit correspondre en taille et en ordre. Il est valide d'avoir des `null` éléments dans la liste de réponses ; elle `ctx.result` est définie sur *null* en conséquence.