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 référence du modèle de mappage du résolveur (VTL)
<a name="resolver-mapping-template-reference"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Les sections suivantes décrivent comment les opérations utilitaires peuvent être utilisées dans les modèles de mappage :
+  [Présentation du modèle de mappage des résolveurs](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html) - En savoir plus sur le fonctionnement des résolveurs dans. AWS AppSync
+  [Guide de programmation du modèle de mappage Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-programming-guide.html) - En savoir plus sur les structures de données VTL de base et la gestion logique.
+  [Référence contextuelle du modèle de mappage du résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html) - En savoir plus sur la carte contextuelle et son utilisation dans les résolveurs.
+  [Référence de l'utilitaire du modèle de mappage Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference.html) - En savoir plus sur l'utilisation des utilitaires pour simplifier le code.
+  [Référence du modèle de mappage des résolveurs pour DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html) - Découvrez comment les résolveurs interagissent avec DynamoDB.
+  [Référence du modèle de mappage du résolveur pour RDS](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-rds.html) - En savoir plus sur la structure du résolveur et les interactions avec RDS.
+  [Référence du modèle de mappage du résolveur pour OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-elasticsearch.html) - En savoir plus sur la structure des demandes et réponses du résolveur et sur les interactions avec OpenSearch le service.
+  [Référence du modèle de mappage du résolveur pour Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-lambda.html) - En savoir plus sur la structure des demandes et des réponses du résolveur et sur les interactions avec Lambda.
+  [Référence du modèle de mappage du résolveur pour EventBridge ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-eventbridge.html) - En savoir plus sur la structure des demandes et réponses du résolveur et sur les interactions avec. EventBridge
+  [Référence du modèle de mappage du résolveur pour la source de données None](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-none.html) - En savoir plus sur la structure de demande et de réponse du résolveur et les interactions avec les sources de données NONE.
+  [Référence du modèle de mappage du résolveur pour HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-http.html) - En savoir plus sur la structure des demandes et des réponses du résolveur et sur les interactions avec les points de terminaison HTTP.

# AWS AppSync présentation du modèle de mappage du résolveur
<a name="resolver-mapping-template-reference-overview"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync vous permet de répondre aux requêtes GraphQL en effectuant des opérations sur vos ressources. Pour chaque champ GraphQL sur lequel vous souhaitez exécuter une requête ou une mutation, un résolveur doit être attaché afin de communiquer avec une source de données. La communication s'effectue généralement par le biais de paramètres ou d'opérations propres à la source de données.

Les résolveurs sont les connecteurs entre GraphQL et une source de données. Ils expliquent AWS AppSync comment traduire une requête GraphQL entrante en instructions pour votre source de données principale, et comment traduire la réponse de cette source de données en réponse GraphQL. Ils sont écrits dans le [langage de modèle Apache Velocity (VTL)](https://velocity.apache.org/engine/1.7/user-guide.html), qui prend votre requête en entrée et génère un document JSON contenant les instructions pour le résolveur. Vous pouvez utiliser des modèles de mappage pour des instructions simples, telles que la transmission d'arguments provenant de champs GraphQL, ou pour des instructions plus complexes, telles que le fait de parcourir des arguments en boucle pour créer un élément avant de l'insérer dans DynamoDB. 

Il existe deux types de résolveurs AWS AppSync qui exploitent les modèles de mappage de manière légèrement différente :
+ Résolveurs d'unités
+ Résolveurs de pipelines

## Résolveurs d'unités
<a name="unit-resolvers"></a>

Les résolveurs d'unités sont des entités autonomes qui incluent uniquement un modèle de demande et de réponse. Utilisez-les pour les opérations simples et uniques, comme lister des éléments à partir d'une seule source de données.
+ Modèles de demande : prenez la demande entrante après l'analyse d'une opération GraphQL et convertissez-la en une configuration de demande pour l'opération de source de données sélectionnée.
+ Modèles de réponses : interprétez les réponses de votre source de données et mappez-les à la forme du type de sortie du champ GraphQL.

## Résolveurs de pipelines
<a name="pipeline-resolvers"></a>

Les résolveurs de pipeline contiennent une ou plusieurs *fonctions* exécutées dans un ordre séquentiel. Chaque fonction inclut un modèle de demande et un modèle de réponse. Un résolveur de pipeline possède également un modèle *avant* et un modèle *après* qui entourent la séquence de fonctions que le modèle contient. Le modèle *After* correspond au type de sortie du champ GraphQL. Les résolveurs de pipeline diffèrent des résolveurs d'unités dans la façon dont le modèle de réponse mappe la sortie. Un résolveur de pipeline peut mapper sur n'importe quelle sortie de votre choix, y compris l'entrée d'une autre fonction ou le modèle *postérieur* du résolveur de pipeline. 

 *Les fonctions* de résolution de pipeline vous permettent d'écrire une logique commune que vous pouvez réutiliser dans plusieurs résolveurs de votre schéma. Les fonctions sont associées directement à une source de données et, comme un résolveur d'unités, contiennent le même format de modèle de mappage de demandes et de réponses.

Le schéma suivant montre le flux de processus d'un résolveur d'unités sur la gauche et d'un résolveur de pipeline sur la droite.

![\[Schéma d'un résolveur d'unités communiquant avec une source de données unique et schéma d'un résolveur de pipeline communiquant avec plusieurs sources de données.\]](http://docs.aws.amazon.com/fr_fr/appsync/latest/devguide/images/unit-pipeline-resolver.png)


Les résolveurs de pipeline contiennent un surensemble des fonctionnalités prises en charge par les résolveurs unitaires, et bien plus encore, au prix d'un peu plus de complexité.

### Anatomie d'un résolveur de pipeline
<a name="anatomy-of-a-pipeline-resolver"></a>

Un résolveur de pipeline est composé d'un modèle **avant** mappage, d'un modèle **après** mappage et d'une liste de fonctions. Chaque fonction possède un modèle de mappage de **requêtes** et de **réponses** qu'elle exécute par rapport à une source de données. Comme un résolveur de pipeline délègue l'exécution à une liste de fonctions, il n'est lié à aucune source de données. Les résolveurs d'unité et les fonctions sont des primitifs qui exécutent l'opération sur les sources de données. Consultez la [présentation du modèle de mappage Resolver](#aws-appsync-resolver-mapping-template-reference-overview) pour plus d'informations.

#### Avant le modèle de mappage
<a name="before-mapping-template"></a>

Le modèle de mappage de demandes d'un résolveur de pipeline, ou l'étape **Before**, vous permet d'exécuter une certaine logique de préparation avant d'exécuter les fonctions définies.

#### Liste des fonctions
<a name="functions-list"></a>

La liste des fonctions d'un résolveur de pipeline est exécutée dans l'ordre. Le résultat évalué du modèle de mappage de demande du résolveur de pipeline est mis à disposition de la première fonction en tant que `$ctx.prev.result`. Chaque sortie d'une fonction est disponible pour la fonction suivante en tant que `$ctx.prev.result`.

#### Modèle de mappage Après
<a name="after-mapping-template"></a>

Le modèle de mappage des réponses d'un résolveur de pipeline, ou l'étape **After**, vous permet d'exécuter une logique de mappage finale entre la sortie de la dernière fonction et le type de champ GraphQL attendu. La sortie de la dernière fonction de la liste de fonctions est disponible dans le modèle de mappage du résolveur de pipeline en tant que `$ctx.prev.result` ou `$ctx.result`.

#### Flux d'exécution
<a name="execution-flow"></a>

Étant donné qu'un résolveur de pipeline est composé de deux fonctions, la liste ci-dessous représente le flux d'exécution lorsque le résolveur est invoqué :

![\[GraphQL request flow diagram showing template processing and data source interactions.\]](http://docs.aws.amazon.com/fr_fr/appsync/latest/devguide/images/PipelineResolver.jpg)


1. Résolveur de pipeline **avant le modèle de** mappage

1. Fonction 1 : Modèle de mappage de demande de fonction

1. Fonction 1 : Appel de source de données

1. Fonction 1 : Modèle de mappage de réponse de fonction

1. Fonction 2 : Modèle de mappage de demande de fonction

1. Fonction 2 : Appel de source de données

1. Fonction 2 : Modèle de mappage de réponse de fonction

1. Résolveur de pipeline **après le modèle** de mappage

**Note**  
Le flux d'exécution du résolveur de pipeline est unidirectionnel et défini de manière statique sur le résolveur.

#### Utilitaires VTL (Apache Velocity Template Language) utiles
<a name="useful-apache-velocity-template-language-vtl-utilities"></a>

À mesure qu'une application devient plus complexe, les utilitaires VTL et les directives permettent de faciliter la productivité de développement. Les utilitaires suivants peuvent vous aider si vous travaillez avec des résolveurs de pipeline.

##### \$1ctx.stash
<a name="ctx-stash"></a>

Le stash est disponible dans chaque résolveur et chaque modèle de mappage de fonctions. `Map` La même instance stash perdure pendant une exécution de résolveur. Cela signifie que vous pouvez utiliser le stash pour transmettre des données arbitraires sur des modèles de mappage de demande et de réponse, et sur des fonctions dans un résolveur de pipeline. Le stash expose les mêmes méthodes que la structure de données [cartographiques Java](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html).

##### \$1ctx.prev.result
<a name="ctx-prev-result"></a>

Le `$ctx.prev.result` représente le résultat de l'opération précédente exécutée dans le résolveur de pipeline.

Si l'opération précédente était le modèle de mappage Before du résolveur de pipeline, elle `$ctx.prev.result` représente le résultat de l'évaluation du modèle et est mise à la disposition de la première fonction du pipeline. Si l'opération précédente est la première fonction, alors `$ctx.prev.result` représente le résultat de la première fonction et il est disponible pour la seconde fonction du pipeline. Si l'opération précédente était la dernière fonction, elle `$ctx.prev.result` représente la sortie de la dernière fonction et est mise à la disposition du modèle After mapping du résolveur de pipeline.

##### \$1return(data: Object)
<a name="return-data-object"></a>

La directive `#return(data: Object)` s'avère utile si vous avez besoin de revenir en arrière prématurément depuis un modèle de mappage. `#return(data: Object)` est analogue au mot clé *return* dans les langages de programmation, car il renvoie au bloc de logique à portée le plus proche. Cela signifie qu'utiliser `#return` dans un modèle de mappage de résolveur renvoie des données à partir du résolveur. L'utilisation de `#return(data: Object)` dans un modèle de mappage de résolveur définit `data` sur le champ GraphQL. De plus, l'utilisation de `#return(data: Object)` à partir d'un modèle de mappage de fonction renvoie des données à partir de la fonction et continue l'exécution vers la prochaine fonction du pipeline ou vers le modèle de mappage de réponse du résolveur.

##### \$1return
<a name="return"></a>

C'est la même chose que`#return(data: Object)`, mais elle `null` sera renvoyée à la place.

##### \$1util.error
<a name="util-error"></a>

L'utilitaire `$util.error` est utile pour envoyer une erreur de champ. L'utilisation de `$util.error` dans un modèle de mappage de fonction envoie immédiatement une erreur de champ qui empêche l'exécution des fonctions suivantes. Pour plus de détails et pour d'autres `$util.error` signatures, consultez la [référence de l'utilitaire de modèle de mappage Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).

##### \$1util.appendError
<a name="util-appenderror"></a>

`$util.appendError` est similaire à `$util.error()`, avec une différence majeure : il n'interrompt pas l'évaluation du modèle de mappage. Au lieu de cela, il signale qu'une erreur s'est produite avec le champ, mais autorise l'évaluation du modèle et renvoie les données. L'utilisation de `$util.appendError` dans une fonction ne perturbera pas le flux d'exécution du pipeline. Pour plus de détails et pour d'autres `$util.error` signatures, consultez la [référence de l'utilitaire de modèle de mappage Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).

## Exemple de modèle
<a name="example-template"></a>

Supposons que vous disposiez d'une source de données DynamoDB et **d'un résolveur d'**unités dans un champ `getPost(id:ID!)` nommé qui renvoie `Post` un type avec la requête GraphQL suivante :

```
getPost(id:1){
    id
    title
    content
}
```

Votre modèle de résolveur peut ressembler à ce qui suit :

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}
```

Ce modèle remplace la valeur du paramètre d'entrée `id` par `1` (au lieu de `${ctx.args.id}`) et génère le code JSON suivant :

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "1" }
    }
}
```

AWS AppSync utilise ce modèle pour générer des instructions permettant de communiquer avec DynamoDB et d'obtenir des données (ou d'effectuer d'autres opérations le cas échéant). Une fois les données renvoyées, AWS AppSync les exécute via un modèle de mappage de réponse facultatif que vous pouvez utiliser pour effectuer des opérations de mise en forme ou de logique sur les données. Par exemple, lorsque nous récupérons les résultats de DynamoDB, ils peuvent ressembler à ceci :

```
{
        "id" : 1,
        "theTitle" : "AWS AppSync works offline!",
        "theContent-part1" : "It also has realtime functionality",
        "theContent-part2" : "using GraphQL"
}
```

Vous pouvez choisir de regrouper deux des champs en un seul avec le modèle de mappage de réponse suivant :

```
{
        "id" : $util.toJson($context.data.id),
        "title" : $util.toJson($context.data.theTitle),
        "content" : $util.toJson("${context.data.theContent-part1} ${context.data.theContent-part2}")
}
```

Voici comment les données sont formatées une fois que le modèle leur a été appliqué :

```
{
        "id" : 1,
        "title" : "AWS AppSync works offline!",
        "content" : "It also has realtime functionality using GraphQL"
}
```

Ces données sont renvoyées au client sous forme de réponse comme suit :

```
{
        "data": {
                "getPost":      {
                        "id" : 1,
                        "title" : "AWS AppSync works offline!",
                        "content" : "It also has realtime functionality using GraphQL"
                }
        }
}
```

Notez que, dans la plupart des cas, les modèles de mappage de réponse sont une simple transmission de données, lesquels sont surtout différents si vous renvoyez un élément individuel ou une liste d'éléments. Pour un élément individuel, la transmission est :

```
$util.toJson($context.result)
```

Pour une liste, la transmission est généralement :

```
$util.toJson($context.result.items)
```

Pour voir d'autres exemples de résolveurs unitaires et de résolveurs de pipeline, consultez les didacticiels sur les [résolveurs](tutorials.md#aws-appsync-tutorials).

## Règles de désérialisation des modèles de mappage évalués
<a name="evaluated-mapping-template-deserialization-rules"></a>

Les modèles de mappage sont évalués selon une chaîne. Dans AWS AppSync, la chaîne de sortie doit suivre une structure JSON pour être valide.

En outre, les règles de désérialisation suivantes sont appliquées.

### Les clés en double ne sont pas autorisées dans les objets JSON
<a name="duplicate-keys-are-not-allowed-in-json-objects"></a>

Si la chaîne de modèle de mappage évaluée représente un objet JSON ou contient un objet qui contient des clés en double, le modèle de mappage renvoie le message d'erreur suivant :

 `Duplicate field 'aField' detected on Object. Duplicate JSON keys are not allowed.` 

Exemple de clé en double dans un modèle de mappage de demande évalué :

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
        "field": "getPost" ## key 'field' has been redefined
    }
}
```

Pour corriger cette erreur, ne redéfinissez pas les clés dans les objets JSON.

### Les caractères de fin ne sont pas autorisés dans les objets JSON
<a name="trailing-characters-are-not-allowed-in-json-objects"></a>

Si la chaîne de modèle de mappage évaluée représente un objet JSON et contient des caractères de fin étrangers, le modèle de mappage renvoie le message d'erreur suivant :

 `Trailing characters at the end of the JSON string are not allowed.` 

Exemple de caractères de fin dans un modèle de mappage de demande évalué :

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
    }
}extraneouschars
```

Pour corriger cette erreur, assurez-vous que les modèles évalués sont strictement conformes à la norme JSON.

# AWS AppSync guide de programmation du modèle de mappage du résolveur
<a name="resolver-mapping-template-reference-programming-guide"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Il s'agit d'un didacticiel de style livre de recettes sur la programmation avec le langage de modèle Apache Velocity (VTL) dans. AWS AppSync Si vous connaissez d'autres langages de programmation tels que JavaScript C ou Java, cela devrait être assez simple.

AWS AppSync utilise VTL pour traduire les requêtes GraphQL des clients en demandes adressées à votre source de données. Ensuite, il inverse ce processus pour convertir la réponse de la source de données en une réponse GraphQL. Le VTL est un langage de modèle logique qui vous permet de manipuler à la fois la demande et la réponse dans le request/response flux standard d'une application Web, en utilisant des techniques telles que :
+ Valeurs par défaut pour les nouveaux éléments
+ Validation et formatage des informations fournies
+ Transformation et mise en forme des données
+ Itération sur des listes, des cartes et des tableaux pour manipuler ou modifier les valeurs
+ Filtrage/modification des réponses en fonction de l'identité de l'utilisateur
+ Vérifications d'autorisation complexes

Par exemple, vous souhaiterez peut-être valider un numéro de téléphone dans le service sur un argument GraphQL ou convertir un paramètre d'entrée en majuscules avant de le stocker dans DynamoDB. Les systèmes clients peuvent également fournir un code, dans le cadre d'un argument GraphQL, d'une demande de jeton JWT ou d'un en-tête HTTP, et ne répondre avec des données que si ce code correspond à une chaîne spécifique dans une liste. Ce sont toutes des vérifications logiques que vous pouvez effectuer avec VTL in AWS AppSync.

VTL permet d'appliquer une logique à l'aide de techniques de programmation qui peuvent vous être familières. Cependant, il est limité à fonctionner dans le request/response flux standard afin de garantir que votre API GraphQL est évolutive à mesure que votre base d'utilisateurs augmente. Comme il est AWS AppSync également compatible en AWS Lambda tant que résolveur, vous pouvez écrire des fonctions Lambda dans le langage de programmation de votre choix (Node.js, Python, Go, Java, etc.) si vous avez besoin de plus de flexibilité.

## Configuration
<a name="setup"></a>

Une technique courante lors de l'apprentissage d'une langue consiste à imprimer les résultats (par exemple, `console.log(variable)` dans JavaScript) pour voir ce qui se passe. Dans ce didacticiel, nous illustrons cela en créant un schéma GraphQL simple et en transmettant une carte de valeurs à une fonction Lambda. La fonction Lambda affiche les valeurs, puis les utilise pour répondre. Cela vous permettra de comprendre le request/response flux et de découvrir les différentes techniques de programmation.

Commencez par créer le schéma GraphQL suivant :

```
type Query {
    get(id: ID, meta: String): Thing
}

type Thing {
    id: ID!
    title: String!
    meta: String
}

schema {
    query: Query
}
```

Créez maintenant la AWS Lambda fonction suivante en utilisant Node.js comme langage :

```
exports.handler = (event, context, callback) => {
    console.log('VTL details: ', event);
    callback(null, event);
};
```

Dans le volet **Sources de données** de la AWS AppSync console, ajoutez cette fonction Lambda en tant que nouvelle source de données. Revenez à la page **Schema (Schéma)** de la console et cliquez sur le bouton **ATTACH (ATTACHER)** situé à droite, en regard de la requête `get(...):Thing`. Pour le modèle de demande, choisissez le modèle existant dans le menu **Invoke and forward arguments (Invoquer et transférer des arguments)**. Pour le modèle de réponse, choisissez **Return Lambda result (Renvoyer le résultat de Lambda)**.

Ouvrez Amazon CloudWatch Logs pour votre fonction Lambda en un seul endroit, puis dans l'onglet **Requêtes** de la AWS AppSync console, exécutez la requête GraphQL suivante :

```
query test {
  get(id:123 meta:"testing"){
    id
    meta
  }
}
```

La réponse GraphQL doit contenir `id:123` et `meta:testing`, parce que la fonction Lambda en fait écho. Au bout de quelques secondes, vous devriez également voir un enregistrement dans CloudWatch Logs contenant ces informations.

## Variables
<a name="variables"></a>

VTL utilise des [références](https://velocity.apache.org/engine/1.7/user-guide.html#references), que vous pouvez utiliser pour stocker ou manipuler les données. Il existe trois types de références dans VTL : les variables, les propriétés et les méthodes. Les variables sont précédées d'un symbole `$` et sont créées avec la directive `#set` :

```
#set($var = "a string")
```

Les variables stockent des types similaires que vous connaissez bien dans d'autres langages, comme des nombres, des chaînes, des tableaux, des listes et des cartes. Vous avez peut-être remarqué qu'une charge utile JSON était envoyée dans le modèle de demande par défaut pour les résolveurs Lambda :

```
"payload": $util.toJson($context.arguments)
```

Quelques points à noter ici : tout d'abord, AWS AppSync fournit plusieurs fonctions pratiques pour les opérations courantes. Dans cet exemple, `$util.toJson` convertit une variable au format JSON. Deuxièmement, la variable `$context.arguments` est automatiquement renseignée à partir d'une demande GraphQL comme un objet carte. Vous pouvez créer une nouvelle carte comme suit :

```
#set( $myMap = {
  "id": $context.arguments.id,
  "meta": "stuff",
  "upperMeta" : $context.arguments.meta.toUpperCase()
} )
```

Vous venez de créer une variable nommée `$myMap`, qui possède des clés de `id`, `meta` et `upperMeta`. Ceci illustre aussi les éléments suivants :
+  `id` est renseignée avec une clé issue des arguments GraphQL. Il est courant dans VTL de saisir des arguments à partir des clients.
+  L'argument `meta` est codé en dur avec une valeur, exposant les valeurs par défaut.
+  `upperMeta` transforme l'argument `meta` à l'aide d'une méthode `.toUpperCase()`.

Placez le code précédent en haut de votre modèle de demande et modifiez `payload` pour utiliser la nouvelle variable `$myMap` :

```
"payload": $util.toJson($myMap)
```

Exécutez votre fonction Lambda et vous pourrez voir le changement de réponse ainsi que ces données dans CloudWatch les journaux. Au fur et à mesure que vous parcourrez le reste de ce didacticiel, nous continuerons à renseigner `$myMap` pour que vous puissiez exécuter des tests similaires.

Vous pouvez également définir des *propriétés* sur vos variables. Ce peut être de simples chaînes, des tableaux ou des éléments JSON :

```
#set($myMap.myProperty = "ABC")
#set($myMap.arrProperty = ["Write", "Some", "GraphQL"])
#set($myMap.jsonProperty = {
    "AppSync" : "Offline and Realtime",
    "Cognito" : "AuthN and AuthZ"
})
```

### Des références discrètes
<a name="quiet-references"></a>

Comme VTL est un langage de création de modèles, par défaut, toute référence que vous lui donnez exécute une méthode `.toString()`. Si la référence n'est pas définie, elle affiche la représentation de référence en tant que chaîne. Par exemple :

```
#set($myValue = 5)
##Prints '5'
$myValue

##Prints '$somethingelse'
$somethingelse
```

Pour résoudre cela, VTL possède une syntaxe de type *référence calme* ou *référence silencieuse*, qui indique au moteur de modèle de supprimer ce comportement. La syntaxe correspondante est `$!{}`. Par exemple, si nous modifions légèrement le code précédent pour utiliser `$!{somethingelse}`, l'affichage est supprimé :

```
#set($myValue = 5)
##Prints '5'
$myValue

##Nothing prints out
$!{somethingelse}
```

## Méthodes d'appel
<a name="calling-methods"></a>

Dans l'exemple précédent, nous vous a montré comment créer une variable et les valeurs définies simultanément. Vous pouvez également procéder en deux étapes en ajoutant des données à votre carte :

```
#set ($myMap = {})
#set ($myList = [])

##Nothing prints out
$!{myMap.put("id", "first value")}
##Prints "first value"
$!{myMap.put("id", "another value")}
##Prints true
$!{myList.add("something")}
```

 **TOUTEFOIS**, vous devez connaître une information importante sur ce comportement. Même si la notation de référence silencieuse `$!{}` vous permet d'appeler des méthodes, comme ci-dessus, elle NE supprime PAS la valeur renvoyée de la méthode exécutée. C'est pourquoi nous avons noté `##Prints "first value"` et `##Prints true` ci-dessus. Cela peut entraîner des erreurs lors d'une itération sur des cartes ou des listes, comme l'insertion d'une valeur là où une clé existe déjà, car la sortie ajoute des chaînes inattendues au modèle lors de l'évaluation.

Une solution de contournement consiste parfois à appeler les méthodes à l'aide d'une directive `#set` et d'ignorer la variable. Par exemple :

```
#set ($myMap = {})
#set($discard = $myMap.put("id", "first value"))
```

Vous pouvez utiliser cette technique dans vos modèles, car elle empêche l'impression de chaînes inattendues dans le modèle. AWS AppSync fournit une fonction pratique alternative qui offre le même comportement dans une notation plus succincte. Cela vous évite d'avoir à réfléchir à ces spécificités de mise en œuvre. Vous pouvez accéder à cette fonction sous `$util.quiet()` ou son alias `$util.qr()`. Par exemple :

```
#set ($myMap = {})
#set ($myList = [])

##Nothing prints out
$util.quiet($myMap.put("id", "first value"))
##Nothing prints out
$util.qr($myList.add("something"))
```

## Chaînes
<a name="strings"></a>

Comme avec de nombreux langages de programmation, il peut être difficile de gérer les chaînes, notamment lorsque vous voulez les générer à partir de variables. Des éléments communs se manifestent dans le cadre de VTL.

Supposons que vous insérez des données sous forme de chaîne dans une source de données telle que DynamoDB, mais qu'elles soient renseignées à partir d'une variable, comme un argument GraphQL. Une chaîne a des guillemets doubles et vous avez simplement besoin de `"${}"` pour référencer la variable dans une chaîne (donc d'aucun `!` comme dans la [notation de référence silencieuse](https://velocity.apache.org/engine/1.7/user-guide.html#quiet-reference-notation)). Ceci est similaire à un modèle littéral dans JavaScript : [https://developer.mozilla. org/en-US/docs/Web/JavaScript/Reference/Template\$1littéraux](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) 

```
#set($firstname = "Jeff")
$!{myMap.put("Firstname", "${firstname}")}
```

Vous pouvez le constater dans les modèles de requête DynamoDB, par `"author": { "S" : "${context.arguments.author}"}` exemple lorsque vous utilisez des arguments provenant de clients GraphQL ou pour la génération automatique d'identifiants, par exemple. `"id" : { "S" : "$util.autoId()"}` Cela signifie que vous pouvez référencer une variable ou le résultat d'une méthode à l'intérieur d'une chaîne pour renseigner les données.

Vous pouvez également utiliser les méthodes publiques de la [classe String](https://docs.oracle.com/javase/6/docs/api/java/lang/String.html) Java, telles que l'extraction d'une sous-chaîne :

```
#set($bigstring = "This is a long string, I want to pull out everything after the comma")
#set ($comma = $bigstring.indexOf(','))
#set ($comma = $comma +2)
#set ($substring = $bigstring.substring($comma))

$util.qr($myMap.put("substring", "${substring}"))
```

La concaténation de chaînes est aussi une tâche très courante. Vous pouvez procéder avec des références de variables seules ou avec des valeurs statiques :

```
#set($s1 = "Hello")
#set($s2 = " World")

$util.qr($myMap.put("concat","$s1$s2"))
$util.qr($myMap.put("concat2","Second $s1 World"))
```

## Boucles
<a name="loops"></a>

Maintenant que vous avez créé des variables et appelé des méthodes, vous pouvez ajouter une logique à votre code. Contrairement à d'autres langages, VTL autorise uniquement des boucles avec un nombre d'itérations prédéterminé. Il n'existe pas de `do..while` dans Velocity. Cette conception garantit que le processus d'évaluation arrivera à son terme et elle fournit des limites pour la scalabilité lorsque vos opérations GraphQL s'exécutent.

L'instruction `#foreach` permet de créer des boucles et nécessite que vous fournissiez une **variable de boucle** et un **objet itérable**, tel qu'un tableau, une liste, une carte ou une collection. Un exemple de programmation standard avec une boucle `#foreach` consiste à itérer sur les éléments d'une collection et à les afficher, pour les prélever et les ajouter à la carte :

```
#set($start = 0)
#set($end = 5)
#set($range = [$start..$end])

#foreach($i in $range)
   ##$util.qr($myMap.put($i, "abc"))
   ##$util.qr($myMap.put($i, $i.toString()+"foo")) ##Concat variable with string
   $util.qr($myMap.put($i, "${i}foo"))     ##Reference a variable in a string with "${varname}"
#end
```

Cet exemple illustre quelques éléments. Le premier est l'utilisation des variables avec l'opérateur `[..]` de plage pour créer un objet itérable. Ensuite, chaque élément est référencé par une variable `$i` que vous pouvez utiliser. Dans l'exemple précédent, vous voyez aussi des **commentaires** qui sont signalés par deux dièses `##`. Ceci illustre également l'utilisation de la variable de boucle dans les clés et les valeurs, ainsi que différentes méthodes de concaténation utilisant les chaînes.

Notez que `$i` est un entier, si bien que vous pouvez appeler une méthode `.toString()`. Pour les types GraphQL de INT, cela peut être utile.

Vous pouvez également utiliser un opérateur de plage directement, par exemple :

```
#foreach($item in [1..5])
    ...
#end
```

## Arrays (tableaux)
<a name="arrays"></a>

Vous avez manipulé une carte jusqu'à ce stade, mais les tableaux sont également courants dans VTL. Avec les tableaux, vous avez également accès à certaines méthodes sous-jacentes telles que `.isEmpty()`, `.size()`, `.set()`, `.get()` et `.add()`, comme illustré ci-dessous :

```
#set($array = [])
#set($idx = 0)

##adding elements
$util.qr($array.add("element in array"))
$util.qr($myMap.put("array", $array[$idx]))

##initialize array vals on create
#set($arr2 = [42, "a string", 21, "test"])

$util.qr($myMap.put("arr2", $arr2[$idx]))
$util.qr($myMap.put("isEmpty", $array.isEmpty()))  ##isEmpty == false
$util.qr($myMap.put("size", $array.size()))

##Get and set items in an array
$util.qr($myMap.put("set", $array.set(0, 'changing array value')))
$util.qr($myMap.put("get", $array.get(0)))
```

L'exemple précédent utilisait la notation d'index de tableau pour récupérer un élément avec`arr2[$idx]`. Vous pouvez effectuer une recherche par nom à partir d'un Map/dictionary de la même manière :

```
#set($result = {
    "Author" : "Nadia",
    "Topic" : "GraphQL"
})

$util.qr($myMap.put("Author", $result["Author"]))
```

Cela est très courant lors du filtrage des résultats provenant des sources de données dans les modèles de réponse lors de l'utilisation de conditions.

## Contrôles conditionnels
<a name="conditional-checks"></a>

La section antérieure avec `#foreach` illustrait des exemples de l'utilisation d'une logique pour transformer les données avec VTL. Vous pouvez également appliquer des contrôles conditionnels pour évaluer les données lors de l'exécution :

```
#if(!$array.isEmpty())
    $util.qr($myMap.put("ifCheck", "Array not empty"))
#else
    $util.qr($myMap.put("ifCheck", "Your array is empty"))
#end
```

La vérification `#if()` ci-dessus d'une expression booléenne est correcte, mais vous pouvez également utiliser des opérateurs et `#elseif()` pour une ramification :

```
#if ($arr2.size() == 0)
    $util.qr($myMap.put("elseIfCheck", "You forgot to put anything into this array!"))
#elseif ($arr2.size() == 1)
    $util.qr($myMap.put("elseIfCheck", "Good start but please add more stuff"))
#else
    $util.qr($myMap.put("elseIfCheck", "Good job!"))
#end
```

Ces deux exemples montrent la négation (\$1) et l'égalité (==). Nous pouvons également utiliser \$1\$1, &&, >, <, >=, <=, et \$1=

```
#set($T = true)
#set($F = false)

#if ($T || $F)
  $util.qr($myMap.put("OR", "TRUE"))
#end

#if ($T && $F)
  $util.qr($myMap.put("AND", "TRUE"))
#end
```

 **Remarque :** Seuls `Boolean.FALSE` et `null` sont considérés comme false dans les conditions. Zéro (0) et les chaînes vides ("") ne sont pas équivalents à false.

## Opérateurs
<a name="operators"></a>

Aucun langage de programmation ne serait complet sans certains opérateurs pour effectuer certaines opérations mathématiques. Voici quelques exemples pour commencer :

```
#set($x = 5)
#set($y = 7)
#set($z = $x + $y)
#set($x-y = $x - $y)
#set($xy = $x * $y)
#set($xDIVy = $x / $y)
#set($xMODy = $x % $y)

$util.qr($myMap.put("z", $z))
$util.qr($myMap.put("x-y", $x-y))
$util.qr($myMap.put("x*y", $xy))
$util.qr($myMap.put("x/y", $xDIVy))
$util.qr($myMap.put("x|y", $xMODy))
```

### Utilisation conjointe de boucles et de conditionnels
<a name="loops-and-conditionals-together"></a>

Il est très courant lors de la transformation de données dans VTL, par exemple avant d'écrire ou de lire dans une source de données, d'itérer sur des objets puis d'effectuer des vérifications avant d'effectuer une action. L'association de certains outils des sections précédentes vous offre un grand nombre de fonctionnalités. Un outil pratique est de savoir que `#foreach` vous fournit automatiquement un nombre (`.count`) sur chaque élément :

```
#foreach ($item in $arr2)
  #set($idx = "item" + $foreach.count)
  $util.qr($myMap.put($idx, $item))
#end
```

Par exemple, vous voulez prélever des valeurs d'une carte seulement si sa taille est inférieure à une valeur donnée. L'utilisation du nombre avec les conditions et l'instruction `#break` vous permet d'écrire :

```
#set($hashmap = {
  "DynamoDB" : "https://aws.amazon.com/dynamodb/",
  "Amplify" : "https://github.com/aws/aws-amplify",
  "DynamoDB2" : "https://aws.amazon.com/dynamodb/",
  "Amplify2" : "https://github.com/aws/aws-amplify"
})

#foreach ($key in $hashmap.keySet())
    #if($foreach.count > 2)
    #break
  #end
    $util.qr($myMap.put($key, $hashmap.get($key)))
#end
```

Le bloc `#foreach` précédent est itéré avec `.keySet()`, que vous pouvez utiliser sur les cartes. Cela vous donne l'accès nécessaire pour obtenir `$key` et référencer la valeur avec un `.get($key)`. Les arguments GraphQL des clients AWS AppSync sont stockés sous forme de carte. Ils peuvent également être itérés avec `.entrySet()` et vous pouvez ensuite accéder à la fois aux clés et aux valeurs en tant qu'ensemble, et renseigner les autres variables ou effectuer des vérifications conditionnelles complexes, telles que la validation ou la transformation de l'entrée :

```
#foreach( $entry in $context.arguments.entrySet() )
#if ($entry.key == "XYZ" && $entry.value == "BAD")
    #set($myvar = "...")
  #else
    #break
  #end
#end
```

D'autres exemples courants sont le remplissage automatique des informations par défaut, comme les versions initiales des objets lors de la synchronisation des données (très importante pour la résolution des conflits) ou le propriétaire par défaut d'un objet pour les vérifications d'autorisation. Mary a créé ce billet de blog, donc :

```
#set($myMap.owner ="Mary")
#set($myMap.defaultOwners = ["Admins", "Editors"])
```

## Contexte
<a name="context"></a>

Maintenant que vous savez comment effectuer des vérifications logiques dans les AWS AppSync résolveurs avec VTL, examinez l'objet de contexte :

```
$util.qr($myMap.put("context", $context))
```

Celui-ci contient toutes les informations auxquelles vous pouvez accéder dans votre demande GraphQL. Pour une explication détaillée, consultez la [référence sur le contexte](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).

## Filtrage
<a name="filtering"></a>

Jusqu'ici dans ce didacticiel, toutes les informations provenant de votre fonction Lambda ont été renvoyées à la requête GraphQL avec une transformation JSON très simple :

```
$util.toJson($context.result)
```

La logique VTL est tout aussi puissante lorsque vous obtenez des réponses à partir d'une source de données, en particulier lors de la réalisation de vérifications d'autorisation sur les ressources. Passons en revue quelques exemples. Tout d'abord, essayez de modifier votre modèle de réponse comme suit :

```
#set($data = {
    "id" : "456",
    "meta" : "Valid Response"
})

$util.toJson($data)
```

Quoi qu'il se passe avec votre opération GraphQL, les valeurs codées en dur sont renvoyées au client. Modifiez cela légèrement pour que le champ `meta` soit renseigné à partir de la réponse Lambda, définie précédemment dans le didacticiel dans la valeur `elseIfCheck` lors de l'examen des conditions :

```
#set($data = {
    "id" : "456"
})

#foreach($item in $context.result.entrySet())
    #if($item.key == "elseIfCheck")
        $util.qr($data.put("meta", $item.value))
    #end
#end

$util.toJson($data)
```

 `$context.result` est une carte. Vous pouvez donc utiliser `entrySet()` pour appliquer une logique sur les clés ou les valeurs renvoyées. Etant donné que `$context.identity` contient des informations sur l'utilisateur qui a effectué l'opération GraphQL, si vous renvoyez les informations d'autorisation à partir de la source de données, vous pouvez décider de renvoyer des données complètes, des données partielles ou aucune donnée à un utilisateur en fonction de votre logique. Modifiez votre modèle de réponse pour qu'il ressemble à ce qui suit :

```
#if($context.result["id"] == 123)
    $util.toJson($context.result)
  #else
    $util.unauthorized()
#end
```

Si vous exécutez votre requête GraphQL, les données seront renvoyées comme d'habitude. Toutefois, si vous modifiez l'argument id en spécifiant autre chose que 123 (`query test { get(id:456 meta:"badrequest"){} }`), vous obtenez un message d'échec d'autorisation.

Vous trouverez d'autres exemples de scénarios d'autorisation dans la section sur les [cas d'utilisation des autorisations](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).

### Exemple de modèle
<a name="appendix-template-sample"></a>

Si vous avez suivi ce didacticiel, vous avez peut-être créé le modèle ci-dessous étape par étape. Si vous ne l'avez pas fait, nous l'incluons ci-dessous pour que vous puissiez le copier à des fins de test.

 **Modèle de demande** 

```
#set( $myMap = {
  "id": $context.arguments.id,
  "meta": "stuff",
  "upperMeta" : "$context.arguments.meta.toUpperCase()"
} )

##This is how you would do it in two steps with a "quiet reference" and you can use it for invoking methods, such as .put() to add items to a Map
#set ($myMap2 = {})
$util.qr($myMap2.put("id", "first value"))

## Properties are created with a dot notation
#set($myMap.myProperty = "ABC")
#set($myMap.arrProperty = ["Write", "Some", "GraphQL"])
#set($myMap.jsonProperty = {
    "AppSync" : "Offline and Realtime",
    "Cognito" : "AuthN and AuthZ"
})

##When you are inside a string and just have ${} without ! it means stuff inside curly braces are a reference
#set($firstname = "Jeff")
$util.qr($myMap.put("Firstname", "${firstname}"))

#set($bigstring = "This is a long string, I want to pull out everything after the comma")
#set ($comma = $bigstring.indexOf(','))
#set ($comma = $comma +2)
#set ($substring = $bigstring.substring($comma))
$util.qr($myMap.put("substring", "${substring}"))

##Classic for-each loop over N items:
#set($start = 0)
#set($end = 5)
#set($range = [$start..$end])
#foreach($i in $range)          ##Can also use range operator directly like #foreach($item in [1...5])
   ##$util.qr($myMap.put($i, "abc"))
   ##$util.qr($myMap.put($i, $i.toString()+"foo")) ##Concat variable with string
   $util.qr($myMap.put($i, "${i}foo"))     ##Reference a variable in a string with "${varname)"
#end

##Operators don't work
#set($x = 5)
#set($y = 7)
#set($z = $x + $y)
#set($x-y = $x - $y)
#set($xy = $x * $y)
#set($xDIVy = $x / $y)
#set($xMODy = $x % $y)
$util.qr($myMap.put("z", $z))
$util.qr($myMap.put("x-y", $x-y))
$util.qr($myMap.put("x*y", $xy))
$util.qr($myMap.put("x/y", $xDIVy))
$util.qr($myMap.put("x|y", $xMODy))

##arrays
#set($array = ["first"])
#set($idx = 0)
$util.qr($myMap.put("array", $array[$idx]))
##initialize array vals on create
#set($arr2 = [42, "a string", 21, "test"])
$util.qr($myMap.put("arr2", $arr2[$idx]))
$util.qr($myMap.put("isEmpty", $array.isEmpty()))  ##Returns false
$util.qr($myMap.put("size", $array.size()))
##Get and set items in an array
$util.qr($myMap.put("set", $array.set(0, 'changing array value')))
$util.qr($myMap.put("get", $array.get(0)))

##Lookup by name from a Map/dictionary in a similar way:
#set($result = {
    "Author" : "Nadia",
    "Topic" : "GraphQL"
})
$util.qr($myMap.put("Author", $result["Author"]))


##Conditional examples
#if(!$array.isEmpty())
$util.qr($myMap.put("ifCheck", "Array not empty"))
#else
$util.qr($myMap.put("ifCheck", "Your array is empty"))
#end

#if ($arr2.size() == 0)
$util.qr($myMap.put("elseIfCheck", "You forgot to put anything into this array!"))
#elseif ($arr2.size() == 1)
$util.qr($myMap.put("elseIfCheck", "Good start but please add more stuff"))
#else
$util.qr($myMap.put("elseIfCheck", "Good job!"))
#end

##Above showed negation(!) and equality (==), we can also use OR, AND, >, <, >=, <=, and !=
#set($T = true)
#set($F = false)
#if ($T || $F)
  $util.qr($myMap.put("OR", "TRUE"))
#end

#if ($T && $F)
  $util.qr($myMap.put("AND", "TRUE"))
#end

##Using the foreach loop counter - $foreach.count
#foreach ($item in $arr2)
  #set($idx = "item" + $foreach.count)
  $util.qr($myMap.put($idx, $item))
#end

##Using a Map and plucking out keys/vals
#set($hashmap = {
    "DynamoDB" : "https://aws.amazon.com/dynamodb/",
    "Amplify" : "https://github.com/aws/aws-amplify",
    "DynamoDB2" : "https://aws.amazon.com/dynamodb/",
    "Amplify2" : "https://github.com/aws/aws-amplify"
})

#foreach ($key in $hashmap.keySet())
    #if($foreach.count > 2)
        #break
    #end
    $util.qr($myMap.put($key, $hashmap.get($key)))
#end

##concatenate strings
#set($s1 = "Hello")
#set($s2 = " World")
$util.qr($myMap.put("concat","$s1$s2"))
$util.qr($myMap.put("concat2","Second $s1 World"))

$util.qr($myMap.put("context", $context))

{
    "version" : "2017-02-28",
    "operation": "Invoke",
    "payload": $util.toJson($myMap)
}
```

 **Modèle de réponse** 

```
#set($data = {
"id" : "456"
})
#foreach($item in $context.result.entrySet())   ##$context.result is a MAP so we use entrySet()
    #if($item.key == "ifCheck")
        $util.qr($data.put("meta", "$item.value"))
    #end
#end

##Uncomment this out if you want to test and remove the below #if check
##$util.toJson($data)

#if($context.result["id"] == 123)
    $util.toJson($context.result)
  #else
    $util.unauthorized()
#end
```

# AWS AppSync référence contextuelle du modèle de mappage du résolveur
<a name="resolver-context-reference"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync définit un ensemble de variables et de fonctions permettant de travailler avec des modèles de mappage de résolveurs. Cela facilite les opérations logiques sur les données avec GraphQL. Le présent document décrit ces fonctions et fournit des exemples d'utilisation des modèles.

## Accès à la variable `$context`
<a name="accessing-the-context"></a>

La variable `$context` est un mappage qui contient toutes les informations contextuelles pour l'appel de votre résolveur. Elle présente la structure suivante :

```
{
   "arguments" : { ... },
   "source" : { ... },
   "result" : { ... },
   "identity" : { ... },
   "request" : { ... },
   "info": { ... }
}
```

**Note**  
Si vous essayez d'accéder à une dictionary/map entrée (par exemple une entrée`context`) à l'aide de sa clé pour récupérer la valeur, le Velocity Template Language (VTL) vous permet d'utiliser directement la notation`<dictionary-element>.<key-name>`. Toutefois, cela peut ne pas fonctionner dans tous les cas, notamment lorsque les noms des clés comprennent des caractères spéciaux (par exemple, un caractère de soulignement « \$1 »). Nous vous recommandons de toujours utiliser la notation `<dictionary-element>.get("<key-name>")`.

Chaque champ dans le mappage `$context` est défini comme suit :

### Champs de `$context`
<a name="accessing-the-context-list"></a>

** `arguments` **  
Carte qui contient tous les arguments GraphQL pour ce champ.

** `identity` **  
Objet qui contient des informations sur l’appelant. Pour en savoir plus sur la structure de ce champ, consultez [Identité](#aws-appsync-resolver-context-reference-identity).

** `source` **  
Carte contenant la résolution du champ parent.

** `stash` **  
Le stash est une carte disponible dans chaque modèle de mappage de résolveur et de fonction. La même instance stash perdure pendant une exécution de résolveur. Cela signifie que vous pouvez utiliser le stash pour transmettre des données arbitraires sur des modèles de mappage de demande et de réponse, et sur des fonctions dans un résolveur de pipeline. Le stash expose les mêmes méthodes que la structure de données [Java Map](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html).

** `result` **  
Un conteneur pour les résultats de ce résolveur. Ce champ n'est disponible que pour les modèles de mappage des réponses.  
Par exemple, si vous résolvez le `author` champ de la requête suivante :  

```
query {
    getPost(id: 1234) {
        postId
        title
        content
        author {
            id
            name
        }
    }
}
```
Ensuite, la variable `$context` complète, disponible lors du traitement d'un modèle de mappage de réponse, peut être :  

```
{
  "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` **  
Le résultat de toute opération précédente exécutée dans un résolveur de pipeline.  
Si l'opération précédente était le modèle de mappage Before du résolveur de pipeline, elle `$ctx.prev.result` représente le résultat de l'évaluation du modèle et est mise à la disposition de la première fonction du pipeline.  
Si l'opération précédente est la première fonction, alors `$ctx.prev.result` représente le résultat de la première fonction et il est disponible pour la seconde fonction du pipeline.  
Si l'opération précédente était la dernière fonction, elle `$ctx.prev.result` représente la sortie de la dernière fonction et est mise à la disposition du modèle After mapping du résolveur de pipeline.

** `info` **  
Objet qui contient des informations sur la demande GraphQL. Pour obtenir la structure de ce champ, veuillez consulter [Infos](#aws-appsync-resolver-context-reference-info).

### Identity
<a name="aws-appsync-resolver-context-reference-identity"></a>

La section `identity` contient les informations sur l'appelant. La forme de cette section dépend du type d'autorisation de votre AWS AppSync API.

Pour plus d'informations sur les options AWS AppSync de sécurité, consultez la section [Autorisation et authentification](security-authz.md#aws-appsync-security).

** Autorisation `API_KEY`**  
Le `identity` champ n'est pas renseigné.

**Autorisation `AWS_LAMBDA`**  
`identity`Il contient la `resolverContext` clé, contenant le même `resolverContext` contenu renvoyé par la fonction Lambda autorisant la demande.

** Autorisation `AWS_IAM`**  
`identity`Il a la forme suivante :  

```
{
    "accountId" : "string",
    "cognitoIdentityPoolId" : "string",
    "cognitoIdentityId" : "string",
    "sourceIp" : ["string"],
    "username" : "string", // IAM user principal
    "userArn" : "string",
    "cognitoIdentityAuthType" : "string", // authenticated/unauthenticated based on the identity type
    "cognitoIdentityAuthProvider" : "string" // the auth provider that was used to obtain the credentials
}
```

** Autorisation `AMAZON_COGNITO_USER_POOLS`**  
`identity`Il a la forme suivante :  

```
{
    "sub" : "uuid",
    "issuer" : "string",
    "username" : "string"
    "claims" : { ... },
    "sourceIp" : ["x.x.x.x"],
    "defaultAuthStrategy" : "string"
}
```

Chaque champ est défini comme suit :

** `accountId` **  
L'identifiant du AWS compte de l'appelant.

** `claims` **  
Demandes de l'utilisateur.

** `cognitoIdentityAuthType` **  
Authentifié ou non authentifié en fonction du type d'identité.

** `cognitoIdentityAuthProvider` **  
Liste séparée par des virgules des informations du fournisseur d'identité externe utilisées pour obtenir les informations d'identification utilisées pour signer la demande.

** `cognitoIdentityId` **  
L'identifiant Amazon Cognito de l'appelant.

** `cognitoIdentityPoolId` **  
L'ID du pool d'identités Amazon Cognito associé à l'appelant.

** `defaultAuthStrategy` **  
Stratégie d'autorisation par défaut pour cet appelant (`ALLOW` ou `DENY`).

** `issuer` **  
Émetteur du jeton.

** `sourceIp` **  
Adresse IP source de l'appelant qui AWS AppSync reçoit. Si la demande n'inclut pas l'`x-forwarded-for`en-tête, la valeur IP source ne contient qu'une seule adresse IP provenant de la connexion TCP. Si la demande inclut un en-tête `x-forwarded-for`, l'adresse IP source est une liste d'adresses IP de l'en-tête `x-forwarded-for` en plus de l'adresse IP de la connexion TCP.

** `sub` **  
UUID de l'utilisateur authentifié.

** `user` **  
Utilisateur IAM.

** `userArn` **  
Le nom de ressource Amazon (ARN) de l'utilisateur IAM.

** `username` **  
Nom de l'utilisateur authentifié. En cas d'autorisation `AMAZON_COGNITO_USER_POOLS`, la valeur de *username* est la valeur de l’attribut *cognito:username*. Dans le cas d'`AWS_IAM`une autorisation, la valeur du *nom d'utilisateur* est la valeur de l' AWS utilisateur principal. Si vous utilisez l'autorisation IAM avec des informations d'identification provenant de pools d'identités Amazon Cognito, nous vous recommandons d'utiliser. `cognitoIdentityId`

### En-têtes de demande d'accès
<a name="aws-appsync-resolver-context-reference-util"></a>

AWS AppSync permet de transmettre des en-têtes personnalisés depuis les clients et d'y accéder dans vos résolveurs GraphQL en utilisant. `$context.request.headers` Vous pouvez ensuite utiliser les valeurs d'en-tête pour des actions telles que l'insertion de données dans une source de données ou les contrôles d'autorisation. Vous pouvez utiliser un ou plusieurs en-têtes de demande à l'`$curl`aide d'une clé d'API depuis la ligne de commande, comme indiqué dans les exemples suivants :

**Exemple d'en-tête unique** 

Supposons que vous définissiez un en-tête `custom` avec la valeur `nadia`, comme suit :

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Il est alors possible d'y accéder avec `$context.request.headers.custom`. Par exemple, il peut se trouver dans la VTL suivante pour DynamoDB :

```
"custom": $util.dynamodb.toDynamoDBJson($context.request.headers.custom)
```

**Exemple d'en-tête multiple** 

Vous pouvez également transmettre plusieurs en-têtes dans une seule demande et y accéder dans le modèle de mappage des résolveurs. Par exemple, si l'`custom`en-tête est défini avec deux valeurs :

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Vous pouvez ensuite y accéder comme s'il s'agissait d'un tableau : par exemple, `$context.request.headers.custom[1]`.

**Note**  
AWS AppSync n'expose pas l'en-tête du cookie dans`$context.request.headers`.

### Accédez au nom de domaine personnalisé de la demande
<a name="aws-access-requested-custom-domain-names"></a>

AWS AppSync prend en charge la configuration d'un domaine personnalisé que vous pouvez utiliser pour accéder à votre GraphQL et aux points de terminaison en temps réel de votre. APIs Lorsque vous faites une demande avec un nom de domaine personnalisé, vous pouvez obtenir le nom de domaine en utilisant`$context.request.domainName`.

Lorsque vous utilisez le nom de domaine du point de terminaison GraphQL par défaut, la valeur est. `null`

### Info (Infos)
<a name="aws-appsync-resolver-context-reference-info"></a>

La section `info` contient des informations sur la demande GraphQL. Cette section se présente sous la forme suivante :

```
{
    "fieldName": "string",
    "parentTypeName": "string",
    "variables": { ... },
    "selectionSetList": ["string"],
    "selectionSetGraphQL": "string"
}
```

Chaque champ est défini comme suit :

** `fieldName` **  
Nom du champ en cours de résolution.

** `parentTypeName` **  
Nom du type parent du champ en cours de résolution.

** `variables` **  
Carte qui contient toutes les variables transmises dans la demande GraphQL.

** `selectionSetList` **  
Représentation sous forme de liste des champs du jeu de sélection GraphQL. Les champs dotés d'un alias sont référencés uniquement par le nom de l'alias, et non par le nom du champ. L'exemple suivant détaille cela.

** `selectionSetGraphQL` **  
Représentation sous forme de chaîne du jeu de sélection, formatée en langage SDL GraphQL. Bien que les fragments ne soient pas fusionnés dans le jeu de sélection, les fragments intégrés sont conservés, comme le montre l'exemple suivant.

**Note**  
Lorsque vous utilisez `$utils.toJson()` on`context.info`, les valeurs renvoyées `selectionSetGraphQL` et celles `selectionSetList` renvoyées ne sont pas sérialisées par défaut.

Par exemple, si vous résolvez le champ `getPost` de la requête suivante :

```
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
  }
}
```

Ensuite, la variable `$context.info` complète, disponible lors du traitement d'un modèle de mappage, peut être :

```
{
  "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`n'expose que les champs appartenant au type actuel. Si le type actuel est une interface ou une union, seuls les champs sélectionnés appartenant à l'interface sont exposés. Par exemple, selon le schéma suivant :

```
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
}
```

Et la requête suivante :

```
query {
    node(id: "post1") {
        id
        ... on Post {
            title
        }

        ... on Blog {
            title
        }
    }
}
```

Lors de l'appel `$ctx.info.selectionSetList` à la résolution du `Query.node` champ, seul `id` est exposé :

```
"selectionSetList": [
    "id"
]
```

## Assainissement des entrées
<a name="sanitizing-inputs"></a>

Les applications doivent assainir les entrées non approuvées pour empêcher toute utilisation non prévue de ces applications par une tierce partie. Comme il `$context` contient des entrées utilisateur dans des propriétés telles que`$context.arguments`,`$context.identity`,`$context.result`,`$context.info.variables`, et`$context.request.headers`, il faut veiller à nettoyer leurs valeurs dans les modèles de mappage.

Étant donné que les modèles de mappage représentent JSON, l'assainissement des entrées consiste à échapper les caractères réservés JSON des chaînes représentant les entrées utilisateur. Il est recommandé d'utiliser l'utilitaire `$util.toJson()` pour échapper les caractères réservés JSON des valeurs de chaîne sensibles lors de leur insertion dans un modèle de mappage.

Par exemple, dans le modèle de mappage de requêtes Lambda suivant, parce que nous avons accédé à une chaîne de saisie client non sécurisée (`$context.arguments.id`), nous l'avons encapsulée `$util.toJson()` pour empêcher les caractères JSON non échappés de casser le modèle JSON.

```
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": $util.toJson($context.arguments.id)
    }
}
```

Contrairement au modèle de mappage ci-dessous, où nous insérons directement `$context.arguments.id` sans désinfection. Cela ne fonctionne pas pour les chaînes contenant des guillemets non échappés ou d'autres caractères réservés JSON, et cela peut entraîner l'échec de votre modèle.

```
## DO NOT DO THIS
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "$context.arguments.id" ## Unsafe! Do not insert $context string values without escaping JSON characters.
    }
}
```

# AWS AppSync référence de l'utilitaire du modèle de mappage du résolveur
<a name="resolver-util-reference"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync définit un ensemble d'utilitaires que vous pouvez utiliser dans un résolveur GraphQL pour simplifier les interactions avec les sources de données. Certains de ces utilitaires sont destinés à une utilisation générale avec n'importe quelle source de données, telle que la génération IDs ou l'horodatage. D'autres sont spécifiques à un type de source de données. Les utilitaires suivants sont disponibles :
+  [Aides utilitaires dans \$1util](https://docs.aws.amazon.com/appsync/latest/devguide/utility-helpers-in-util.html) - La variable \$1util contient des méthodes utilitaires générales pour vous aider à travailler avec les données. Sauf indication contraire, tous les utilitaires emploient le jeu de caractères UTF-8.
+ [ AppSync directives](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-directives.html) - AppSync expose des directives pour faciliter la productivité des développeurs lors de l'écriture en VTL.
+  [Assistants temporels dans \$1util.time - La variable \$1util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time.html) contient des méthodes datetime permettant de générer des horodatages, de convertir des formats de date/heure et d'analyser des chaînes de datetime. La syntaxe des formats datetime est basée sur celle-ci [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), à laquelle vous pouvez vous référer pour de plus amples informations.
+ [Les assistants de liste contenus dans \$1util.list - \$1util.list](https://docs.aws.amazon.com/appsync/latest/devguide/list-helpers-in-util-list.html) contiennent des méthodes qui facilitent les opérations de liste courantes, telles que la suppression ou la conservation d'éléments d'une liste pour filtrer les cas d'utilisation.
+  [Les aides cartographiques contenues dans \$1util.map - \$1util.map](https://docs.aws.amazon.com/appsync/latest/devguide/utility-helpers-in-map.html) contiennent des méthodes qui facilitent les opérations cartographiques courantes, telles que la suppression ou la conservation d'éléments d'une carte pour filtrer les cas d'utilisation.
+  [Les assistants DynamoDB contenus dans \$1util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb.html) - \$1util.dynamodb contiennent des méthodes d'assistance qui facilitent l'écriture et la lecture de données sur Amazon DynamoDB, telles que le mappage automatique des types et le formatage. 
+  [Les aides Amazon RDS dans \$1util.rds - \$1util.rds](https://docs.aws.amazon.com/appsync/latest/devguide/rds-helpers-in-util-rds.html) contiennent des méthodes d'assistance qui mettent en forme les opérations RDS en supprimant les données superflues dans les résultats de résultat.
+  [Helpers HTTP dans \$1util.http - L'utilitaire \$1util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http.html) fournit des méthodes d'assistance que vous pouvez utiliser pour gérer les paramètres des requêtes HTTP et pour ajouter des en-têtes de réponse.
+  [Les aides XML dans \$1util.xml - \$1util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-utils-xml.html) contiennent des méthodes d'assistance qui peuvent faciliter la traduction des réponses XML en JSON ou dans un dictionnaire.
+  [Les aides à la transformation de \$1util.transform - \$1util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform.html) contiennent des méthodes d'assistance qui facilitent l'exécution d'opérations complexes sur des sources de données, telles que les opérations de filtrage DynamoDB.
+  [Les aides mathématiques de \$1util.math - \$1util.math](https://docs.aws.amazon.com/appsync/latest/devguide/math-helpers-in-util-math.html) contiennent des méthodes pour faciliter les opérations mathématiques courantes.
+  [Les assistants de chaîne dans \$1util.str - \$1util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str.html) contiennent des méthodes pour faciliter les opérations de chaîne courantes.
+  [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions.html) - \$1extensions contient un ensemble de méthodes permettant d'effectuer des actions supplémentaires dans vos résolveurs.

# Aides utilitaires dans \$1util
<a name="utility-helpers-in-util"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

La `$util` variable contient des méthodes utilitaires générales pour vous aider à travailler avec les données. Sauf indication contraire, tous les utilitaires emploient le jeu de caractères UTF-8.

## Utilitaires d'analyse JSON
<a name="utility-helpers-in-json-parsing"></a>

### Liste des utilitaires d'analyse JSON
<a name="utility-helpers-in-json-parsing-list"></a>

** **`$util.parseJson(String) : Object`** **  
Prend la chaîne JSON (obtenue à l’aide de stringify) et renvoie une représentation objet du résultat.

** **`$util.toJson(Object) : String`** **  
Accepte un objet et retourne une représentation JSON de cet objet obtenue à l'aide de stringify.

## Utilitaires d'encodage
<a name="utility-helpers-in-encoding"></a>

### Liste des utilitaires d'encodage
<a name="utility-helpers-in-encoding-list"></a>

** **`$util.urlEncode(String) : String`** **  
Renvoie la chaîne en entrée sous la forme d'une chaîne codée `application/x-www-form-urlencoded`.

** **`$util.urlDecode(String) : String`** **  
Décode une chaîne codée `application/x-www-form-urlencoded` sous sa forme initiale non codée.

** **`$util.base64Encode( byte[] ) : String`** **  
Code les données d'entrée en une chaîne codée en base64.

** **`$util.base64Decode(String) : byte[]`** **  
Décode les données d’une chaîne encodée en base64.

## Utilitaires de génération d'identifiants
<a name="utility-helpers-in-id-gen"></a>

### Liste des utilitaires de génération d'identifiants
<a name="utility-helpers-in-id-gen-list"></a>

** **`$util.autoId() : String`** **  
Renvoie un UUID 128 bits généré de façon aléatoire.

****`$util.autoUlid() : String`****  
Renvoie un ULID (identifiant lexicographiquement sortable universel unique) de 128 bits généré aléatoirement.

****`$util.autoKsuid() : String`****  
Renvoie un KSUID (K-Sortable Unique Identifier) de 128 bits généré aléatoirement en base62 et codé sous forme de chaîne d'une longueur de 27.

## Utils d'erreur
<a name="utility-helpers-in-error"></a>

### Liste des utilitaires d'erreur
<a name="utility-helpers-in-error-list"></a>

** `$util.error(String)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel.

** `$util.error(String, String)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel. Vous pouvez également spécifier un`errorType`.

** `$util.error(String, String, Object)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel. Vous pouvez également spécifier un `errorType` et un `data` champ. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.  
`data`sera filtré en fonction de l'ensemble de sélection de requêtes.

** `$util.error(String, String, Object, Object)` **  
Lève une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, un `errorType` champ, un `data` champ et un `errorInfo` champ peuvent être spécifiés. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.   
`data`sera filtré en fonction de l'ensemble de sélection de requêtes. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.  
`errorInfo`**ne sera PAS** filtré en fonction de l'ensemble de sélection de requêtes.

** `$util.appendError(String)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. Contrairement à `$util.error(String)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant.

** `$util.appendError(String, String)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, il est possible de spécifier un champ `errorType`. Contrairement à `$util.error(String, String)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant.

** `$util.appendError(String, String, Object)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. Il est également possible de spécifier un champ `errorType` et un champ `data`. Contrairement à `$util.error(String, String, Object)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.   
`data`sera filtré en fonction de l'ensemble de sélection de requêtes.

** `$util.appendError(String, String, Object, Object)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, un `errorType` champ, un `data` champ et un `errorInfo` champ peuvent être spécifiés. Contrairement à `$util.error(String, String, Object, Object)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.  
`data`sera filtré en fonction de l'ensemble de sélection de requêtes. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL.  
`errorInfo`**ne sera PAS** filtré en fonction de l'ensemble de sélection de requêtes.

## Utilitaires de validation des conditions
<a name="utility-helpers-in-condition"></a>

### Liste des utilitaires de validation des conditions
<a name="utility-helpers-in-condition-list"></a>

** `$util.validate(Boolean, String) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message spécifié.

** `$util.validate(Boolean, String, String) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message et le type d'erreur spécifiés.

** `$util.validate(Boolean, String, String, Object) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message et le type d'erreur spécifiés, ainsi que les données à renvoyer dans la réponse.

## Utilitaires de comportement nuls
<a name="utility-helpers-in-null-behavior"></a>

### Liste d'utilitaires de comportement nulle
<a name="utility-helpers-in-null-behavior-list"></a>

** `$util.isNull(Object) : Boolean` **  
Renvoie la valeur true si l'objet fourni a la valeur null.

** `$util.isNullOrEmpty(String) : Boolean` **  
Renvoie la valeur true si les données fournies ont une valeur null ou une chaîne vide. Sinon, la valeur renvoyée est false.

** `$util.isNullOrBlank(String) : Boolean` **  
Renvoie la valeur true si les données fournies ont une valeur null ou une chaîne vide. Sinon, la valeur renvoyée est false.

** `$util.defaultIfNull(Object, Object) : Object` **  
Renvoie le premier objet si la valeur n'est pas null. Sinon, renvoie le deuxième objet en tant qu'« objet par défaut ».

** `$util.defaultIfNullOrEmpty(String, String) : String` **  
Renvoie la première chaîne si la valeur n'est pas null ou vide. Sinon, renvoie la deuxième chaîne en tant que « chaîne (string) par défaut ».

** `$util.defaultIfNullOrBlank(String, String) : String` **  
Renvoie la première chaîne si la valeur n'est pas null ou vide. Sinon, renvoie la deuxième chaîne en tant que « chaîne (string) par défaut ».

## Utilitaires de correspondance de modèles
<a name="utility-helpers-in-pattern-matching"></a>

### Liste d'utilitaires correspondant au type et au modèle
<a name="utility-helpers-in-type-pattern-matching-list"></a>

** `$util.typeOf(Object) : String` **  
Renvoie une chaîne décrivant le type de l'objet. Identifications de type prises en charge : « Null », « Number », « String », « Map », « List », « Boolean ». Si un type ne peut pas être identifié, le type de retour est « Object ».

** `$util.matches(String, String) : Boolean` **  
Renvoie la valeur true si le modèle spécifié dans le premier argument correspond aux données fournies dans le deuxième argument. Le modèle doit être une expression régulière, telle que `$util.matches("a*b", "aaaaab")`. La fonctionnalité est basée sur [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), que vous pouvez référencer à titre de documentation ultérieure.

** `$util.authType() : String` **  
Renvoie une chaîne décrivant le type d'authentification multiple utilisé par une demande, renvoyant soit « IAM Authorization », « User Pool Authorization », « Open ID Connect Authorization », soit « API Key Authorization ».

## Utilitaires de validation d'objets
<a name="utility-helpers-in-object-validation"></a>

### Liste des utilitaires de validation d'objets
<a name="utility-helpers-in-object-validation-list"></a>

** `$util.isString(Object) : Boolean` **  
Renvoie vrai si l'objet est une chaîne.

** `$util.isNumber(Object) : Boolean` **  
Renvoie vrai si l'objet est un nombre.

** `$util.isBoolean(Object) : Boolean` **  
Renvoie vrai si l'objet est un booléen.

** `$util.isList(Object) : Boolean` **  
Renvoie vrai si l'objet est une liste.

** `$util.isMap(Object) : Boolean` **  
Renvoie vrai si l'objet est une carte.

## CloudWatch utilitaires de journalisation
<a name="utility-helpers-in-logging"></a>

### CloudWatch liste des utilitaires de journalisation
<a name="utility-helpers-in-cloudwatch-logs"></a>

**`$util.log.info(Object) : Void`**  
Enregistre la représentation sous forme de chaîne de l'objet fourni dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau de la demande et au niveau du champ est activée avec le niveau du journal `ALL``INFO`, ou `DEBUG` sur une API.

**`$util.log.info(String, Object...) : Void`**  
Enregistre la représentation sous forme de chaîne des objets fournis dans le flux de journal demandé lorsque la journalisation au niveau de la demande et au niveau du champ est activée avec le niveau de CloudWatch journalisation sur une API. `ALL` Cet utilitaire remplacera toutes les variables indiquées par « \$1\$1 » dans le premier format d'entrée String par la représentation sous forme de chaîne des objets fournis dans l'ordre.

**`$util.log.debug(Object) : Void`**  
Enregistre la représentation sous forme de chaîne de l'objet fourni dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau de la demande et au niveau du champ est activée au niveau du journal `ALL` ou `DEBUG` sur une API.

**`$util.log.debug(String, Object...) : Void`**  
Enregistre la représentation sous forme de chaîne des objets fournis dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau du champ est activée avec le niveau du journal `DEBUG` ou le niveau du journal `ALL` sur une API. Cet utilitaire remplacera toutes les variables indiquées par « \$1\$1 » dans le premier format d'entrée String par la représentation sous forme de chaîne des objets fournis dans l'ordre.

**`$util.log.error(Object) : Void`**  
Enregistre la représentation sous forme de chaîne de l'objet fourni dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau du champ est activée avec **n'importe quel** niveau de journal (`ALL``INFO`,`DEBUG`,, etc.) sur une API.

**`$util.log.error(String, Object...) : Void`**  
Enregistre la représentation sous forme de chaîne des objets fournis dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau du champ est activée avec le niveau du journal `ERROR` ou le niveau du journal `ALL` sur une API. Cet utilitaire remplacera toutes les variables indiquées par « \$1\$1 » dans le premier format d'entrée String par la représentation sous forme de chaîne des objets fournis dans l'ordre.

## Utilitaires de comportement des valeurs renvoyées
<a name="utility-helpers-in-return-behavior"></a>

### Liste des utilitaires relatifs au comportement des valeurs renvoyées
<a name="utility-helpers-in-behavior-list"></a>

****`$util.qr()`** et `$util.quiet()` **  
Exécute une instruction VTL tout en supprimant la valeur renvoyée. Cela est utile pour exécuter des méthodes sans utiliser d'espaces réservés temporaires, tels que l'ajout d'éléments à une carte. Par exemple :  

```
#set ($myMap = {})
#set($discard = $myMap.put("id", "first value"))
```
Devient :  

```
#set ($myMap = {})
$util.qr($myMap.put("id", "first value"))
```  
** `$util.escapeJavaScript(String) : String` **  
Renvoie la chaîne d'entrée sous forme de chaîne JavaScript échappée.  
** `$util.urlEncode(String) : String` **  
Renvoie la chaîne en entrée sous la forme d'une chaîne codée `application/x-www-form-urlencoded`.  
** `$util.urlDecode(String) : String` **  
Décode une chaîne codée `application/x-www-form-urlencoded` sous sa forme initiale non codée.  
** `$util.base64Encode( byte[] ) : String` **  
Code les données d'entrée en une chaîne codée en base64.  
** `$util.base64Decode(String) : byte[]` **  
Décode les données d’une chaîne encodée en base64.  
** `$util.parseJson(String) : Object` **  
Prend la chaîne JSON (obtenue à l’aide de stringify) et renvoie une représentation objet du résultat.  
** `$util.toJson(Object) : String` **  
Accepte un objet et retourne une représentation JSON de cet objet obtenue à l'aide de stringify.  
** `$util.autoId() : String` **  
Renvoie un UUID 128 bits généré de façon aléatoire.  
****`$util.autoUlid() : String`****  
Renvoie un ULID (identifiant lexicographiquement sortable universel unique) de 128 bits généré aléatoirement.  
****`$util.autoKsuid() : String`****  
Renvoie un KSUID (K-Sortable Unique Identifier) de 128 bits généré aléatoirement en base62 et codé sous forme de chaîne d'une longueur de 27.  
** `$util.unauthorized()` **  
Lève `Unauthorized` pour le champ en cours de résolution. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour déterminer s'il convient d'autoriser l'appelant à résoudre le champ.  
** `$util.error(String)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel.  
** `$util.error(String, String)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel. Vous pouvez également spécifier un`errorType`.  
** `$util.error(String, String, Object)` **  
Lève une erreur personnalisée. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour détecter une erreur dans la demande ou dans le résultat de l'appel. Vous pouvez également spécifier un `errorType` et un `data` champ. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `data` est filtré en fonction du jeu de sélection de la requête.  
** `$util.error(String, String, Object, Object)` **  
Lève une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, il est possible de spécifier un champ `errorType`, un champ `data` et un champ `errorInfo`. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `data` est filtré en fonction du jeu de sélection de la requête. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `errorInfo` **N'EST PAS** filtré en fonction du jeu de sélection de la requête.  
** `$util.appendError(String)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. Contrairement à `$util.error(String)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant.  
** `$util.appendError(String, String)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, il est possible de spécifier un champ `errorType`. Contrairement à `$util.error(String, String)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant.  
** `$util.appendError(String, String, Object)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. Il est également possible de spécifier un champ `errorType` et un champ `data`. Contrairement à `$util.error(String, String, Object)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `data` est filtré en fonction du jeu de sélection de la requête.  
** `$util.appendError(String, String, Object, Object)` **  
Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, il est possible de spécifier un champ `errorType`, un champ `data` et un champ `errorInfo`. Contrairement à `$util.error(String, String, Object, Object)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `data` est filtré en fonction du jeu de sélection de la requête. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. **Remarque** : `errorInfo` **N'EST PAS** filtré en fonction du jeu de sélection de la requête.  
** `$util.validate(Boolean, String) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message spécifié.  
** `$util.validate(Boolean, String, String) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message et le type d'erreur spécifiés.  
** `$util.validate(Boolean, String, String, Object) : void` **  
Si la condition est fausse, lancez un CustomTemplateException avec le message et le type d'erreur spécifiés, ainsi que les données à renvoyer dans la réponse.  
** `$util.isNull(Object) : Boolean` **  
Renvoie la valeur true si l'objet fourni a la valeur null.  
** `$util.isNullOrEmpty(String) : Boolean` **  
Renvoie la valeur true si les données fournies ont une valeur null ou une chaîne vide. Sinon, la valeur renvoyée est false.  
** `$util.isNullOrBlank(String) : Boolean` **  
Renvoie la valeur true si les données fournies ont une valeur null ou une chaîne vide. Sinon, la valeur renvoyée est false.  
** `$util.defaultIfNull(Object, Object) : Object` **  
Renvoie le premier objet si la valeur n'est pas null. Sinon, renvoie le deuxième objet en tant qu'« objet par défaut ».  
** `$util.defaultIfNullOrEmpty(String, String) : String` **  
Renvoie la première chaîne si la valeur n'est pas null ou vide. Sinon, renvoie la deuxième chaîne en tant que « chaîne (string) par défaut ».  
** `$util.defaultIfNullOrBlank(String, String) : String` **  
Renvoie la première chaîne si la valeur n'est pas null ou vide. Sinon, renvoie la deuxième chaîne en tant que « chaîne (string) par défaut ».  
** `$util.isString(Object) : Boolean` **  
Renvoie la valeur true si l'objet est une chaîne.  
** `$util.isNumber(Object) : Boolean` **  
Renvoie la valeur true si l'objet est un nombre.  
** `$util.isBoolean(Object) : Boolean` **  
Renvoie la valeur true si l'objet est une valeur booléenne.  
** `$util.isList(Object) : Boolean` **  
Renvoie la valeur true si l'objet est une liste.  
** `$util.isMap(Object) : Boolean` **  
Renvoie la valeur true si l'objet est une map.  
** `$util.typeOf(Object) : String` **  
Renvoie une chaîne décrivant le type de l'objet. Identifications de type prises en charge : « Null », « Number », « String », « Map », « List », « Boolean ». Si un type ne peut pas être identifié, le type de retour est « Object ».  
** `$util.matches(String, String) : Boolean` **  
Renvoie la valeur true si le modèle spécifié dans le premier argument correspond aux données fournies dans le deuxième argument. Le modèle doit être une expression régulière, telle que `$util.matches("a*b", "aaaaab")`. La fonctionnalité est basée sur [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), que vous pouvez référencer à titre de documentation ultérieure.  
** `$util.authType() : String` **  
Renvoie une chaîne décrivant le type d'authentification multiple utilisé par une demande, renvoyant soit « IAM Authorization », « User Pool Authorization », « Open ID Connect Authorization », soit « API Key Authorization ».  
****`$util.log.info(Object) : Void`****  
Enregistre la représentation sous forme de chaîne de l'objet fourni dans le flux de journal demandé lorsque la journalisation au niveau de la demande et au niveau du champ est activée avec le niveau de CloudWatch journalisation sur une API. `ALL`  
****`$util.log.info(String, Object...) : Void`****  
Enregistre la représentation sous forme de chaîne des objets fournis dans le flux de journal demandé lorsque la journalisation au niveau de la demande et au niveau du champ est activée avec le niveau de CloudWatch journalisation sur une API. `ALL` Cet utilitaire remplacera toutes les variables indiquées par « \$1\$1 » dans le premier format d'entrée String par la représentation sous forme de chaîne des objets fournis dans l'ordre.  
****`$util.log.error(Object) : Void`****  
Enregistre la représentation sous forme de chaîne de l'objet fourni dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau du champ est activée avec le niveau du journal `ERROR` ou le niveau du journal `ALL` sur une API.  
****`$util.log.error(String, Object...) : Void`****  
Enregistre la représentation sous forme de chaîne des objets fournis dans le flux de journal demandé lorsque la CloudWatch journalisation au niveau du champ est activée avec le niveau du journal `ERROR` ou le niveau du journal `ALL` sur une API. Cet utilitaire remplacera toutes les variables indiquées par « \$1\$1 » dans le premier format d'entrée String par la représentation sous forme de chaîne des objets fournis dans l'ordre.

** `$util.escapeJavaScript(String) : String` **  
Renvoie la chaîne d'entrée sous forme de chaîne JavaScript échappée.

## Autorisation du résolveur
<a name="utility-helpers-in-resolver-auth"></a>

### Liste d'autorisations du résolveur
<a name="utility-helpers-in-resolver-auth-list"></a>

** `$util.unauthorized()` **  
Lève `Unauthorized` pour le champ en cours de résolution. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour déterminer s'il convient d'autoriser l'appelant à résoudre le champ.

# AWS AppSync directives
<a name="aws-appsync-directives"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync expose des directives pour faciliter la productivité des développeurs lors de l'écriture en VTL.

## Utilitaires de directives
<a name="utility-helpers-in-directives"></a>

****`#return(Object)`****  
Vous `#return(Object)` permet de revenir prématurément à partir de n'importe quel modèle de mappage. `#return(Object)`est analogue au mot clé *return* dans les langages de programmation, car il retournera à partir du bloc logique le plus proche. L'utilisation de `#return(Object)` l'intérieur d'un modèle de mappage du résolveur reviendra du résolveur. De plus, l'utilisation `#return(Object)` à partir d'un modèle de mappage de fonctions revient à la fonction et poursuit l'exécution soit vers la fonction suivante du pipeline, soit vers le modèle de mappage de réponse du résolveur.

****`#return`****  
La `#return` directive présente les mêmes comportements que`#return(Object)`, mais elle `null` sera renvoyée à la place.

# Des aides temporelles dans \$1util.time
<a name="time-helpers-in-util-time"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

La variable `$util.time` contient les méthodes datetime pour aider à générer les horodatages, à convertir d'un format datetime à l'autre et à analyser les chaînes datetime. La syntaxe des formats datetime est basée sur [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)laquelle vous pouvez vous référer pour obtenir de la documentation supplémentaire. Nous fournissons quelques exemples ci-dessous, ainsi qu'une liste des méthodes et des descriptions disponibles.

## Temps et utilités
<a name="utility-helpers-in-time"></a>

### Liste des heures et des outils
<a name="utility-helpers-in-time-list"></a>

** `$util.time.nowISO8601() : String` **  
Renvoie une représentation sous forme de chaîne de l'UTC au [ISO8601format](https://en.wikipedia.org/wiki/ISO_8601).

** `$util.time.nowEpochSeconds() : long` **  
Renvoie le nombre de secondes entre l'époque Unix 1970-01-01T00:00:00Z et maintenant.

** `$util.time.nowEpochMilliSeconds() : long` **  
Renvoie le nombre de millisecondes entre l'époque Unix 1970-01-01T00:00:00Z et maintenant.

** `$util.time.nowFormatted(String) : String` **  
Renvoie une chaîne de l'horodatage actuel (UTC) à l'aide du format spécifié à partir d'un type d'entrée String (chaîne).

** `$util.time.nowFormatted(String, String) : String` **  
Renvoie une chaîne de l'horodatage actuel pour un fuseau horaire à l'aide du format et du fuseau spécifiés à partir de types d'entrée String (chaîne).

** `$util.time.parseFormattedToEpochMilliSeconds(String, String) : Long` **  
Analyse un horodatage transmis sous forme de chaîne avec un format contenant un fuseau horaire, puis renvoie l'horodatage en millisecondes depuis l'époque.

** `$util.time.parseFormattedToEpochMilliSeconds(String, String, String) : Long` **  
Analyse un horodatage transmis sous forme de chaîne avec un format et un fuseau horaire, puis renvoie l'horodatage en millisecondes depuis l'époque.

** `$util.time.parseISO8601ToEpochMilliSeconds(String) : Long` **  
Analyse un ISO8601 horodatage transmis sous forme de chaîne, puis renvoie l'horodatage en millisecondes depuis l'époque.

** `$util.time.epochMilliSecondsToSeconds(long) : long` **  
Convertit une époque Unix en millisecondes en une époque Unix en secondes.

** `$util.time.epochMilliSecondsToISO8601(long) : String` **  
Convertit l'horodatage d'une époque en millisecondes en horodatage. ISO8601

** `$util.time.epochMilliSecondsToFormatted(long, String) : String` **  
Convertit l'horodatage d'une époque en millisecondes, transmis sous sa forme la plus longue, en un horodatage formaté selon le format fourni en UTC.

** `$util.time.epochMilliSecondsToFormatted(long, String, String) : String` **  
Convertit un horodatage en millisecondes d'époque, transmis sous forme de long, en un horodatage formaté selon le format fourni dans le fuseau horaire fourni.

## Exemples de fonctions autonomes
<a name="standalone-function-examples"></a>

```
$util.time.nowISO8601()                                            : 2018-02-06T19:01:35.749Z
$util.time.nowEpochSeconds()                                       : 1517943695
$util.time.nowEpochMilliSeconds()                                  : 1517943695750
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ")                    : 2018-02-06 19:01:35+0000
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ", "+08:00")          : 2018-02-07 03:01:35+0800
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ", "Australia/Perth") : 2018-02-07 03:01:35+0800
```

## Exemples de conversion
<a name="conversion-examples"></a>

```
#set( $nowEpochMillis = 1517943695758 )
$util.time.epochMilliSecondsToSeconds($nowEpochMillis)                                     : 1517943695
$util.time.epochMilliSecondsToISO8601($nowEpochMillis)                                     : 2018-02-06T19:01:35.758Z
$util.time.epochMilliSecondsToFormatted($nowEpochMillis, "yyyy-MM-dd HH:mm:ssZ")           : 2018-02-06 19:01:35+0000
$util.time.epochMilliSecondsToFormatted($nowEpochMillis, "yyyy-MM-dd HH:mm:ssZ", "+08:00") : 2018-02-07 03:01:35+0800
```

## Exemples d'analyse syntaxique
<a name="parsing-examples"></a>

```
$util.time.parseISO8601ToEpochMilliSeconds("2018-02-01T17:21:05.180+08:00")                          : 1517476865180
$util.time.parseFormattedToEpochMilliSeconds("2018-02-02 01:19:22+0800", "yyyy-MM-dd HH:mm:ssZ")     : 1517505562000
$util.time.parseFormattedToEpochMilliSeconds("2018-02-02 01:19:22", "yyyy-MM-dd HH:mm:ss", "+08:00") : 1517505562000
```

## Utilisation avec des scalaires AWS AppSync définis
<a name="usage-with-aws-scalars"></a>

Les formats suivants sont compatibles avec `AWSDate`, `AWSDateTime`, et `AWSTime`.

```
$util.time.nowFormatted("yyyy-MM-dd[XXX]", "-07:00:30")               : 2018-07-11-07:00
$util.time.nowFormatted("yyyy-MM-dd'T'HH:mm:ss[XXXXX]", "-07:00:30")  : 2018-07-11T15:14:15-07:00:30
```

# Répertorier les assistants dans \$1util.list
<a name="list-helpers-in-util-list"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.list`contient des méthodes destinées à faciliter les opérations de liste courantes, telles que la suppression ou la conservation d'éléments d'une liste pour filtrer les cas d'utilisation.

## Liste des utilitaires
<a name="utility-helpers-in-list-utils"></a>

** `$util.list.copyAndRetainAll(List, List) : List` **  
Fait une copie superficielle de la liste fournie dans le premier argument tout en ne conservant que les éléments spécifiés dans le second argument, s'ils sont présents. Tous les autres éléments sont supprimés de la copie.

** `$util.list.copyAndRemoveAll(List, List) : List` **  
Effectue une copie superficielle de la liste fournie dans le premier argument tout en supprimant tous les éléments dont l'élément est spécifié dans le deuxième argument, s'ils sont présents. Tous les autres éléments sont conservés dans la copie.

** `$util.list.sortList(List, Boolean, String) : List` **  
Trie une liste d'objets, qui est fournie dans le premier argument. Si le deuxième argument est vrai, la liste est triée par ordre décroissant ; si le second argument est faux, la liste est triée par ordre croissant. Le troisième argument est le nom de chaîne de la propriété utilisée pour trier une liste d'objets personnalisés. S'il s'agit d'une liste de chaînes, d'entiers, de flottants ou de doubles uniquement, le troisième argument peut être n'importe quelle chaîne aléatoire. Si tous les objets ne sont pas de la même classe, la liste d'origine est renvoyée. Seules les listes contenant un maximum de 1 000 objets sont prises en charge. Voici un exemple d'utilisation de cet utilitaire :   

```
 INPUT:      $util.list.sortList([{"description":"youngest", "age":5},{"description":"middle", "age":45}, {"description":"oldest", "age":85}], false, "description")
 OUTPUT:     [{"description":"middle", "age":45}, {"description":"oldest", "age":85}, {"description":"youngest", "age":5}]
```

# Assistants cartographiques dans \$1util.map
<a name="utility-helpers-in-map"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.map`contient des méthodes destinées à faciliter les opérations cartographiques courantes, telles que la suppression ou la conservation d'éléments d'une carte pour filtrer les cas d'utilisation.

## Utilitaires cartographiques
<a name="utility-helpers-in-map-list"></a>

** `$util.map.copyAndRetainAllKeys(Map, List) : Map` **  
Effectue une copie superficielle de la première carte en ne conservant que les clés spécifiées dans la liste, si elles sont présentes. Toutes les autres clés sont supprimées de la copie.

** `$util.map.copyAndRemoveAllKeys(Map, List) : Map` **  
Effectue une copie superficielle de la première carte tout en supprimant toutes les entrées où la clé est spécifiée dans la liste, si elles sont présentes. Toutes les autres clés sont conservées dans la copie.

# Assistants DynamoDB dans \$1util.dynamodb
<a name="dynamodb-helpers-in-util-dynamodb"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.dynamodb`contient des méthodes d'assistance qui facilitent l'écriture et la lecture de données dans Amazon DynamoDB, telles que le mappage automatique des types et le formatage. Ces méthodes sont conçues pour mapper automatiquement les types primitifs et les listes au format d'entrée DynamoDB approprié, qui est `Map` un des formats. `{ "TYPE" : VALUE }`

Par exemple, auparavant, un modèle de mappage de demandes destiné à créer un nouvel élément dans DynamoDB aurait pu ressembler à ceci :

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : { "S" : "$util.autoId()" }
    },
    "attributeValues" : {
         "title" : { "S" : $util.toJson($ctx.args.title) },
         "author" : { "S" : $util.toJson($ctx.args.author) },
         "version" : { "N", $util.toJson($ctx.args.version) }
    }
}
```

Si nous voulions ajouter des champs à l'objet, nous devrions mettre à jour la requête GraphQL dans le schéma, ainsi que le modèle de mappage de demande. Cependant, nous pouvons désormais restructurer notre modèle de mappage des demandes afin qu'il récupère automatiquement les nouveaux champs ajoutés dans notre schéma et les ajoute à DynamoDB avec les types appropriés :

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },
    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```

Dans l'exemple précédent, nous utilisons l'`$util.dynamodb.toDynamoDBJson(...)`assistant pour prendre automatiquement l'identifiant généré et le convertir en représentation DynamoDB d'un attribut de chaîne. Nous prenons ensuite tous les arguments, les convertissons en leurs représentations DynamoDB et les affichons dans `attributeValues` le champ du modèle.

Chaque assistant possède deux versions : une version qui renvoie un objet (par exemple, `$util.dynamodb.toString(...)`) et une version qui renvoie l'objet en tant que chaîne JSON (par exemple, `$util.dynamodb.toStringJson(...)`). Dans l'exemple précédent, nous avons utilisé la version qui renvoie les données sous la forme d'une chaîne JSON. Si vous souhaitez manipuler l'objet avant qu'il ne soit utilisé dans le modèle, vous pouvez choisir à la place de renvoyer un objet :

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },

    #set( $myFoo = $util.dynamodb.toMapValues($ctx.args) )
    #set( $myFoo.version = $util.dynamodb.toNumber(1) )
    #set( $myFoo.timestamp = $util.dynamodb.toString($util.time.nowISO8601()))

    "attributeValues" : $util.toJson($myFoo)
}
```

Dans l'exemple précédent, nous retournons les arguments convertis comme map au lieu d'une chaîne JSON, ajoutons les champs `version` et `timestamp` avant de les exporter vers le champ `attributeValues` du modèle à l'aide de `$util.toJson(...)`.

La version JSON de chacun des assistants est équivalente à l'encapsulage de la version autre que la version JSON dans `$util.toJson(...)`. Par exemple, les instructions suivantes sont exactement identiques :

```
$util.toStringJson("Hello, World!")
$util.toJson($util.toString("Hello, World!"))
```

## vers DynamoDB
<a name="utility-helpers-in-toDynamoDB"></a>

### Liste des utilitaires de ToDynamoDB
<a name="utility-helpers-in-toDynamoDB-list"></a>

** `$util.dynamodb.toDynamoDB(Object) : Map` **  
Outil général de conversion d'objets pour DynamoDB qui convertit les objets d'entrée en une représentation DynamoDB appropriée. La façon dont il représente certains types est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  
**Exemple de chaîne**  

```
Input:      $util.dynamodb.toDynamoDB("foo")
Output:     { "S" : "foo" }
```
**Exemple de numéro**  

```
Input:      $util.dynamodb.toDynamoDB(12345)
Output:     { "N" : 12345 }
```
**Exemple booléen**  

```
Input:      $util.dynamodb.toDynamoDB(true)
Output:     { "BOOL" : true }
```
**Exemple de liste**  

```
Input:      $util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output:     {
               "L" : [
                   { "S" : "foo" },
                   { "N" : 123 },
                   {
                       "M" : {
                           "bar" : { "S" : "baz" }
                       }
                   }
               ]
           }
```
**Exemple de carte**  

```
Input:      $util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "M" : {
                   "foo"  : { "S" : "bar" },
                   "baz"  : { "N" : 1234 },
                   "beep" : {
                       "L" : [
                           { "S" : "boop" }
                       ]
                   }
               }
           }
```

****`$util.dynamodb.toDynamoDBJson(Object) : String`** **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toDynamoDB(Object) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires ToString
<a name="utility-helpers-in-toString"></a>

### Liste des utilitaires ToString
<a name="utility-helpers-in-toString-list"></a>

****`$util.dynamodb.toString(String) : String`** **  
Convertit une chaîne d'entrée au format de chaîne DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toString("foo")
Output:     { "S" : "foo" }
```

** `$util.dynamodb.toStringJson(String) : Map` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toString(String) : String`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.toStringSet(List<String>) : Map` **  
Convertit une liste contenant des chaînes au format de jeu de chaînes DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output:     { "SS" : [ "foo", "bar", "baz" ] }
```

** `$util.dynamodb.toStringSetJson(List<String>) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toStringSet(List<String>) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utils ToNumber
<a name="utility-helpers-in-toNumber"></a>

### Liste des utilitaires ToNumber
<a name="utility-helpers-in-toNumber-list"></a>

** `$util.dynamodb.toNumber(Number) : Map` **  
Convertit un nombre au format numérique DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toNumber(12345)
Output:     { "N" : 12345 }
```

** `$util.dynamodb.toNumberJson(Number) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toNumber(Number) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.toNumberSet(List<Number>) : Map` **  
Convertit une liste de nombres au format d'ensemble de numéros DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output:     { "NS" : [ 1, 23, 4.56 ] }
```

** `$util.dynamodb.toNumberSetJson(List<Number>) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toNumberSet(List<Number>) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires ToBinary
<a name="utility-helpers-in-toBinary"></a>

### Liste des utilitaires ToBinary
<a name="utility-helpers-in-toBinary-list"></a>

** `$util.dynamodb.toBinary(String) : Map` **  
Convertit les données binaires codées sous forme de chaîne base64 au format binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toBinary("foo")
Output:     { "B" : "foo" }
```

** `$util.dynamodb.toBinaryJson(String) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toBinary(String) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.toBinarySet(List<String>) : Map` **  
Convertit une liste de données binaires codées sous forme de chaînes base64 au format d'ensemble binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output:     { "BS" : [ "foo", "bar", "baz" ] }
```

** `$util.dynamodb.toBinarySetJson(List<String>) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toBinarySet(List<String>) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires ToBoolean
<a name="utility-helpers-in-toBoolean"></a>

### Liste des utilitaires ToBoolean
<a name="utility-helpers-in-toBoolean-list"></a>

** `$util.dynamodb.toBoolean(Boolean) : Map` **  
Convertit un booléen au format booléen DynamoDB approprié. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toBoolean(true)
Output:     { "BOOL" : true }
```

** `$util.dynamodb.toBooleanJson(Boolean) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toBoolean(Boolean) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires ToNull
<a name="utility-helpers-in-toNull"></a>

### Liste des utilitaires ToNull
<a name="utility-helpers-in-toNull-list"></a>

** `$util.dynamodb.toNull() : Map` **  
Renvoie une valeur nulle au format DynamoDB nul. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toNull()
Output:     { "NULL" : null }
```

** `$util.dynamodb.toNullJson() : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toNull() : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires ToList
<a name="utility-helpers-in-toList"></a>

### Liste des utilitaires ToList
<a name="utility-helpers-in-toList-list"></a>

****`$util.dynamodb.toList(List) : Map`** **  
Convertit une liste d'objets au format de liste DynamoDB. Chaque élément de la liste est également converti au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output:     {
               "L" : [
                   { "S" : "foo" },
                   { "N" : 123 },
                   {
                       "M" : {
                           "bar" : { "S" : "baz" }
                       }
                   }
               ]
           }
```

** `$util.dynamodb.toListJson(List) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toList(List) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires TomaP
<a name="utility-helpers-in-toMap"></a>

### Liste des utilitaires de TomaP
<a name="utility-helpers-in-toMap-list"></a>

** `$util.dynamodb.toMap(Map) : Map` **  
Convertit une carte au format de carte DynamoDB. Chaque valeur de la carte est également convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "M" : {
                   "foo"  : { "S" : "bar" },
                   "baz"  : { "N" : 1234 },
                   "beep" : {
                       "L" : [
                           { "S" : "boop" }
                       ]
                   }
               }
           }
```

** `$util.dynamodb.toMapJson(Map) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toMap(Map) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.toMapValues(Map) : Map` **  
Crée une copie de la carte dans laquelle chaque valeur a été convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »).  

```
Input:      $util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output:     {
               "foo"  : { "S" : "bar" },
               "baz"  : { "N" : 1234 },
               "beep" : {
                   "L" : [
                       { "S" : "boop" }
                   ]
               }
           }
```
Cela est légèrement différent du fait `$util.dynamodb.toMap(Map) : Map` qu'il renvoie uniquement le contenu de la valeur d'attribut DynamoDB, mais pas la valeur d'attribut complète elle-même. Par exemple, les instructions suivantes sont exactement identiques :  

```
$util.dynamodb.toMapValues($map)
$util.dynamodb.toMap($map).get("M")
```

** `$util.dynamodb.toMapValuesJson(Map) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toMapValues(Map) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

## Utilitaires de l'objet S3
<a name="utility-helpers-in-S3Object"></a>

### Liste des utilitaires de S3Object
<a name="utility-helpers-in-S3Object-list"></a>

** `$util.dynamodb.toS3Object(String key, String bucket, String region) : Map` **  
Convertit la clé, le compartiment et la région en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toS3Object("foo", "bar", region = "baz")
Output:     { "S" : "{ \"s3\" : { \"key\" : \"foo", \"bucket\" : \"bar", \"region\" : \"baz" } }" }
```

** `$util.dynamodb.toS3ObjectJson(String key, String bucket, String region) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toS3Object(String key, String bucket, String region) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map` **  
Convertit la clé, le compartiment, la région et la version facultative en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB.  

```
Input:      $util.dynamodb.toS3Object("foo", "bar", "baz", "beep")
Output:     { "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" }
```

** `$util.dynamodb.toS3ObjectJson(String key, String bucket, String region, String version) : String` **  
Identique à la valeur de l'attribut DynamoDB`$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map`, mais renvoie la valeur de l'attribut DynamoDB sous forme de chaîne codée JSON.

** `$util.dynamodb.fromS3ObjectJson(String) : Map` **  
Accepte la valeur de chaîne d'un objet DynamoDB S3 et renvoie une carte contenant la clé, le compartiment, la région et la version facultative.  

```
Input:      $util.dynamodb.fromS3ObjectJson({ "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" })
Output:     { "key" : "foo", "bucket" : "bar", "region" : "baz", "version" : "beep" }
```

# Assistants Amazon RDS dans \$1util.rds
<a name="rds-helpers-in-util-rds"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.rds`contient des méthodes d'assistance qui mettent en forme les opérations Amazon RDS en supprimant les données superflues dans les résultats de résultat.

## Liste des utilitaires de \$1util.rds
<a name="rds-helpers-in-util-rds-list"></a>

****`$util.rds.toJsonString(String serializedSQLResult): String`****  
Renvoie un `String` en transformant le format de résultat brut des opérations de l'API de données Amazon Relational Database Service (Amazon RDS) sous forme de chaînes en une chaîne plus concise. La chaîne renvoyée est une liste sérialisée d'enregistrements SQL du jeu de résultats. Chaque enregistrement est représenté sous la forme d'un ensemble de paires clé-valeur. Les clés sont les noms de colonnes correspondantes.  
Si l'instruction correspondante dans l'entrée était une requête SQL qui provoque une mutation (par exemple INSERT, UPDATE, DELETE), une liste vide est renvoyée. Par exemple, la requête `select * from Books limit 2` fournit le résultat brut de l'opération Amazon RDS Data :  

```
{
    "sqlStatementResults": [
        {
            "numberOfRecordsUpdated": 0,
            "records": [
                [
                    {
                        "stringValue": "Mark Twain"
                    },
                    {
                        "stringValue": "Adventures of Huckleberry Finn"
                    },
                    {
                        "stringValue": "978-1948132817"
                    }
                ],
                [
                    {
                        "stringValue": "Jack London"
                    },
                    {
                        "stringValue": "The Call of the Wild"
                    },
                    {
                        "stringValue": "978-1948132275"
                    }
                  ]
            ],
            "columnMetadata": [
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "author",
                    "precision": 200,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "author"
                },
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "title",
                    "precision": 200,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "title"
                },
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "ISBN-13",
                    "precision": 15,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "ISBN-13"
                }
            ]
        }
    ]
}
```
`util.rds.toJsonString`C'est :  

```
[
  {
    "author": "Mark Twain",
    "title": "Adventures of Huckleberry Finn",
    "ISBN-13": "978-1948132817"
  },
  {
    "author": "Jack London",
    "title": "The Call of the Wild",
    "ISBN-13": "978-1948132275"
  },
]
```

****`$util.rds.toJsonObject(String serializedSQLResult): Object`****  
C'est la même chose que`util.rds.toJsonString`, mais le résultat est un JSON`Object`.

# assistants HTTP dans \$1util.http
<a name="http-helpers-in-utils-http"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

L'`$util.http`utilitaire fournit des méthodes d'assistance que vous pouvez utiliser pour gérer les paramètres des requêtes HTTP et pour ajouter des en-têtes de réponse.

## Liste des utilitaires de \$1util.http
<a name="http-helpers-in-utils-http-list"></a>

** `$util.http.copyHeaders(Map) : Map` **  
Copie les en-têtes de la carte, à l'exception des en-têtes HTTP restreints suivants :  
+ transfer-encoding
+ connection
+ host
+ expect
+ keep-alive
+ upgrade
+ proxy-authenticate
+ proxy-authorization
+ te
+ content-length
Vous pouvez utiliser cet utilitaire pour transférer les en-têtes de requête vers votre point de terminaison HTTP en aval.  

```
{
    ...
    "params": {
        ...
        "headers": $util.http.copyHeaders($ctx.request.headers),
        ...
    },
    ...
}
```

**\$1util.http. addResponseHeader(Chaîne, objet)**  
Ajoute un seul en-tête personnalisé avec le nom (`String`) et la valeur (`Object`) de la réponse. Les limites suivantes s'appliquent :  
+ Outre la liste des en-têtes restreints pour`copyHeaders(Map)`, les noms d'en-têtes ne peuvent correspondre à aucun des éléments suivants :
  + Access-Control-Allow-Credentials
  + Access-Control-Allow-Origin
  + Access-Control-Expose-Headers
  + Access-Control-Max-Age
  + Access-Control-Allow-Methods
  + Access-Control-Allow-Headers
  + Vary
  + Content-Type
+ Les noms d'en-tête ne peuvent pas commencer par les préfixes restreints `x-amzn-` ou`x-amz-`.
+ La taille des en-têtes de réponse personnalisés ne peut pas dépasser 4 Ko. Cela inclut les noms et les valeurs des en-têtes.
+ Vous devez définir chaque en-tête de réponse une fois par opération GraphQL. Toutefois, si vous définissez plusieurs fois un en-tête personnalisé portant le même nom, la définition la plus récente apparaît dans la réponse. Tous les en-têtes sont pris en compte dans la limite de taille d'en-tête, quel que soit leur nom.
+ Les en-têtes dont le nom est vide ou restreint `(String)` ou dont la valeur est nulle `(Object)` seront ignorés et produiront une `ResponseHeaderError` erreur qui sera ajoutée à la `errors` sortie de l'opération.

```
export function request(ctx) {
  util.http.addResponseHeader('itemsCount', 7)
  util.http.addResponseHeader('render', ctx.args.render)
  return {}
}
```

****`$util.http.addResponseHeaders(Map)`****  
Ajoute plusieurs en-têtes de réponse à la réponse à partir de la carte de noms `(String)` et de valeurs `(Object)` spécifiée. Les mêmes limites répertoriées pour la `addResponseHeader(String, Object)` méthode s'appliquent également à cette méthode.  

```
export function request(ctx) {
  const headers = {
    headerInt: 12,
    headerString: 'stringValue',
    headerObject: {
      field1: 7,
      field2: 'string'
    }
  }
  util.http.addResponseHeaders(headers)
  return {}
}
```

# assistants XML dans \$1util.xml
<a name="xml-helpers-in-utils-xml"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.xml`contient des méthodes d'assistance qui peuvent faciliter la traduction des réponses XML en JSON ou en dictionnaire.

## Liste des utilitaires de \$1util.xml
<a name="xml-helpers-in-utils-xml-list"></a>

****`$util.xml.toMap(String) : Map`****  
Convertit une chaîne XML en dictionnaire.  

```
Input:

<?xml version="1.0" encoding="UTF-8"?>
<posts>
<post>
  <id>1</id>
  <title>Getting started with GraphQL</title>
</post>
</posts>

Output (JSON representation):

{
  "posts":{
    "post":{
      "id":1,
      "title":"Getting started with GraphQL"
    }
  }
}


Input:

<?xml version="1.0" encoding="UTF-8"?>
<posts>
<post>
  <id>1</id>
  <title>Getting started with GraphQL</title>
</post>
<post>
  <id>2</id>
  <title>Getting started with AWS AppSync</title>
</post>
</posts>

Output (JSON representation):

{
  "posts":{
    "post":[
        {
          "id":1,
          "title":"Getting started with GraphQL"
        },
        {
          "id":2,
          "title":"Getting started with AWS AppSync"
        }
    ]
  }
}
```

****`$util.xml.toJsonString(String) : String`****  
Convertit une chaîne XML en chaîne JSON. Ceci est similaire à *TomAp*, sauf que la sortie est une chaîne. Cela est utile si vous souhaitez convertir et renvoyer directement la réponse XML à partir d'un objet HTTP vers JSON.

****`$util.xml.toJsonString(String, Boolean) : String`****  
Convertit une chaîne XML en chaîne JSON avec un paramètre booléen facultatif pour déterminer si vous souhaitez coder le JSON par chaîne.

# Aides à la transformation dans \$1util.transform
<a name="transformation-helpers-in-utils-transform"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.transform`contient des méthodes d'assistance qui facilitent l'exécution d'opérations complexes sur des sources de données, telles que les opérations de filtrage Amazon DynamoDB.

## Aides à la transformation
<a name="transformation-helpers-conversions"></a>

### Liste des outils d'aide à la transformation
<a name="transformation-helpers-in-utils-transform-list"></a>

****`$util.transform.toDynamoDBFilterExpression(Map) : Map`****  
Convertit une chaîne d'entrée en une expression de filtre à utiliser avec DynamoDB.  

```
Input:

$util.transform.toDynamoDBFilterExpression({
    "title":{
      "contains":"Hello World"
    }
  })

Output:

{
    "expression" : "contains(#title, :title_contains)"
    "expressionNames" : {
        "#title" : "title",
    },
    "expressionValues" : {
        ":title_contains" : { "S" : "Hello World" }
    },
}
```

****`$util.transform.toElasticsearchQueryDSL(Map) : Map`****  
Convertit l'entrée donnée en son expression OpenSearch Query DSL équivalente, en la renvoyant sous forme de chaîne JSON.  

```
Input:

$util.transform.toElasticsearchQueryDSL({
    "upvotes":{
        "ne":15,
        "range":[
            10,
            20
        ]
    },
    "title":{
        "eq":"hihihi",
        "wildcard":"h*i"
    }
  })

Output:
{
    "bool":{
      "must":[
          {
            "bool":{
              "must":[
                  {
                    "bool":{
                      "must_not":{
                        "term":{
                          "upvotes":15
                        }
                      }
                    }
                  },
                  {
                    "range":{
                      "upvotes":{
                        "gte":10,
                        "lte":20
                      }
                    }
                  }
              ]
            }
          },
          {
            "bool":{
              "must":[
                  {
                    "term":{
                      "title":"hihihi"
                    }
                  },
                  {
                  "wildcard":{
                      "title":"h*i"
                    }
                  }
              ]
            }
          }
      ]
    }
}
```
L'opérateur par défaut est supposé être AND.

## Filtres d'abonnement pour les aides à la transformation
<a name="transformation-helpers-conversions-subscription-filters"></a>

### Transformation Helpers (abonnement, filtres, liste d'utilitaires)
<a name="transformation-helpers-in-utils-transform-list"></a>

****`$util.transform.toSubscriptionFilter(Map) : Map`****  
Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `$util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`$extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions).

****`$util.transform.toSubscriptionFilter(Map, List) : Map`****  
Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `$util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`$extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions).  
Le premier argument est l'objet `Map` d'entrée converti en objet d'`SubscriptionFilter`expression. Le deuxième argument est un nom `List` de champ qui est ignoré dans le premier objet `Map` d'entrée lors de la construction de l'objet `SubscriptionFilter` d'expression.

****`$util.transform.toSubscriptionFilter(Map, List, Map) : Map`****  
Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `$util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`$extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions).   
Le premier argument est l'objet `Map` d'entrée converti en objet d'`SubscriptionFilter`expression, le deuxième argument est un nom `List` de champ qui sera ignoré dans le premier objet `Map` d'entrée, et le troisième argument est un objet `Map` d'entrée soumis à des règles strictes qui est inclus lors de la construction de l'objet `SubscriptionFilter` d'expression. Ces règles strictes sont incluses dans l'objet `SubscriptionFilter` d'expression de telle sorte qu'au moins l'une des règles soit satisfaite pour passer le filtre d'abonnement.

## Arguments du filtre d'abonnement
<a name="subscription-filter-arguments"></a>

Le tableau suivant explique comment les arguments des utilitaires suivants sont définis :
+ `$util.transform.toSubscriptionFilter(Map) : Map`
+ `$util.transform.toSubscriptionFilter(Map, List) : Map`
+ `$util.transform.toSubscriptionFilter(Map, List, Map) : Map`

------
#### [ Argument 1: Map ]

L'argument 1 est un `Map` objet dont les valeurs clés sont les suivantes :
+ noms de champs
+ « et »
+ « ou »

Pour les noms de champs sous forme de clés, les conditions relatives aux entrées de ces champs sont sous la forme de`"operator" : "value"`. 

L'exemple suivant montre comment ajouter des entrées au `Map` :

```
"field_name" : {
                    "operator1" : value             
               }

## We can have multiple conditions for the same field_name: 

"field_name" : {
                    "operator1" : value             
                    "operator2" : value
                    .
                    .
                    .                  
               }
```

Lorsqu'un champ comporte au moins deux conditions, toutes ces conditions sont considérées comme utilisant l'opération OR.

L'entrée `Map` peut également comporter des touches « et » et « ou », ce qui implique que toutes les entrées qu'elles contiennent doivent être jointes en utilisant la logique AND ou OR en fonction de la clé. Les valeurs clés « et » et « ou » supposent un ensemble de conditions.

```
"and" : [
            
            {
                "field_name1" : {
                    "operator1" : value             
                }
             },
             
             {
                "field_name2" : {
                    "operator1" : value             
                }
             },
             .
             .
        ].
```

Notez que vous pouvez imbriquer « et » et « ou ». C'est-à-dire que vous pouvez avoir imbriqué « et » /"ou » dans un autre bloc « et » /"ou ». Toutefois, cela ne fonctionne pas pour les champs simples.

```
"and" : [
            
            {
                "field_name1" : {
                    "operator" : value             
                }
             },
             
             {
                "or" : [
                            {
                                "field_name2" : {
                                    "operator" : value             
                                }
                            },
                            
                            {
                                "field_name3" : {
                                    "operator" : value             
                                }
                            }
              
                        ].
```

L'exemple suivant montre une entrée de l'*argument 1* utilisant`$util.transform.toSubscriptionFilter(Map) : Map`.

**Entrée (s)**

Argument 1 : Carte :

```
{
  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "gt": 2000
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

**Sortie**

Le résultat est un `Map` objet :

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "lte",
          "value": 50
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Admin"
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "lte",
          "value": 50
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "gte",
          "value": 20
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Admin"
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "percentageUp",
          "operator": "gte",
          "value": 20
        },
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 2000
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    }
  ]
}
```

------
#### [ Argument 2: List ]

L'argument 2 contient des noms `List` de champs qui ne doivent pas être pris en compte dans l'entrée `Map` (argument 1) lors de la construction de l'objet `SubscriptionFilter` d'expression. Ils `List` peuvent également être vides.

L'exemple suivant montre les entrées de l'argument 1 et de l'argument 2 en utilisant`$util.transform.toSubscriptionFilter(Map, List) : Map`.

**Entrée (s)**

Argument 1 : Carte :

```
{

  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "gt": 20
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

Argument 2 : Liste :

```
["percentageUp", "author"]
```

**Sortie**

Le résultat est un `Map` objet :

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        }
      ]
    }
  ]
}
```

------
#### [ Argument 3: Map ]

L'argument 3 est un `Map` objet dont les noms de champs sont des valeurs clés (il ne peut pas y avoir « et » ou « ou »). Pour les noms de champs sous forme de clés, les conditions relatives à ces champs sont des entrées sous la forme de`"operator" : "value"`. Contrairement à l'argument 1, l'argument 3 ne peut pas avoir plusieurs conditions dans la même clé. De plus, l'argument 3 ne contient pas de clause « et » ou « ou », il n'y a donc aucune imbrication non plus.

L'argument 3 représente une liste de règles strictes, qui sont ajoutées à l'objet `SubscriptionFilter` d'expression afin qu'**au moins l'une** de ces conditions soit remplie pour passer le filtre.

```
{
  "fieldname1": {
    "operator": value
  },
  "fieldname2": {
    "operator": value
  }
}
.
.
.
```

L'exemple suivant montre les entrées de l'*argument 1*, de l'*argument 2* et de l'*argument 3* en utilisant`$util.transform.toSubscriptionFilter(Map, List, Map) : Map`.

**Entrée (s)**

Argument 1 : Carte :

```
{
  "percentageUp": {
    "lte": 50,
    "gte": 20
  },
  "and": [
    {
      "title": {
        "ne": "Book1"
      }
    },
    {
      "downvotes": {
        "lt": 20
      }
    }
  ],
  "or": [
    {
      "author": {
        "eq": "Admin"
      }
    },
    {
      "isPublished": {
        "eq": false
      }
    }
  ]
}
```

Argument 2 : Liste :

```
["percentageUp", "author"]
```

Argument 3 : Carte :

```
{
  "upvotes": {
    "gte": 250
  },
  "author": {
    "eq": "Person1"
  }
}
```

**Sortie**

Le résultat est un `Map` objet :

```
{
  "filterGroup": [
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        },
        {
          "fieldName": "upvotes",
          "operator": "gte",
          "value": 250
        }
      ]
    },
    {
      "filters": [
        {
          "fieldName": "title",
          "operator": "ne",
          "value": "Book1"
        },
        {
          "fieldName": "downvotes",
          "operator": "gt",
          "value": 20
        },
        {
          "fieldName": "isPublished",
          "operator": "eq",
          "value": false
        },
        {
          "fieldName": "author",
          "operator": "eq",
          "value": "Person1"
        }
      ]
    }
  ]
}
```

------

# Assistants mathématiques dans \$1util.math
<a name="math-helpers-in-util-math"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.math`contient des méthodes pour faciliter les opérations mathématiques courantes. 

## Liste des utilitaires de \$1util.math
<a name="math-helpers-in-util-math-list"></a>

** `$util.math.roundNum(Double) : Integer` **  
Prend un double et l'arrondit à l'entier le plus proche. 

** `$util.math.minVal(Double, Double) : Double` **  
Prend deux doubles et renvoie la valeur minimale entre les deux doubles.

** `$util.math.maxVal(Double, Double) : Double` **  
Prend deux doubles et renvoie la valeur maximale entre les deux doubles.

** `$util.math.randomDouble() : Double` **  
Renvoie un double aléatoire compris entre 0 et 1.  
Cette fonction ne doit pas être utilisée pour tout ce qui nécessite un caractère aléatoire à entropie élevé (par exemple, la cryptographie).

** `$util.math.randomWithinRange(Integer, Integer) : Integer` **  
Renvoie une valeur entière aléatoire comprise dans la plage spécifiée, le premier argument indiquant la valeur inférieure de la plage et le second la valeur supérieure de la plage.   
Cette fonction ne doit pas être utilisée pour tout ce qui nécessite un caractère aléatoire à entropie élevé (par exemple, la cryptographie).

# assistants de chaîne dans \$1util.str
<a name="str-helpers-in-util-str"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.str`contient des méthodes pour faciliter les opérations courantes sur les chaînes de caractères. 

## Liste des utilitaires de \$1util.str
<a name="str-helpers-in-util-str-list"></a>

** `$util.str.toUpper(String) : String` **  
Prend une chaîne et la convertit pour qu'elle soit entièrement en majuscules. 

** `$util.str.toLower(String) : String` **  
Prend une chaîne de caractères et la convertit en minuscules.

** `$util.str.toReplace(String, String, String) : String` **  
Remplace une sous-chaîne dans une chaîne par une autre chaîne. Le premier argument indique la chaîne sur laquelle effectuer l'opération de remplacement. Le deuxième argument indique la sous-chaîne à remplacer. Le troisième argument indique la chaîne par laquelle remplacer le deuxième argument. Voici un exemple d'utilisation de cet utilitaire :   

```
 INPUT:      $util.str.toReplace("hello world", "hello", "mellow")
 OUTPUT:     "mellow world"
```

** `$util.str.normalize(String, String) : String` **  
Normalise une chaîne à l'aide de l'une des quatre formes de normalisation Unicode : NFC, NFD, NFKC ou NFKD. Le premier argument est la chaîne à normaliser. Le deuxième argument est « nfc », « nfd », « nfkc » ou « nfkd », spécifiant le type de normalisation à utiliser pour le processus de normalisation.

# Extensions
<a name="extensions"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$extensions`contient un ensemble de méthodes permettant d'effectuer des actions supplémentaires dans vos résolveurs.

## Extensions de mise en cache
<a name="caching-extensions-list"></a>

**`$extensions.evictFromApiCache(String, String, Object) : Object`**  
Permet d'expulser un élément du cache AWS AppSync côté serveur. Le premier argument est le nom du type. Le deuxième argument est le nom du champ. Le troisième argument est un objet contenant des éléments de paire clé-valeur qui spécifient la valeur de la clé de mise en cache. Vous devez placer les éléments dans l'objet dans le même ordre que les clés de mise en cache dans le résolveur mis en cache. `cachingKey`  
Cet utilitaire ne fonctionne que pour les mutations, pas pour les requêtes.

## Extensions d'abonnement
<a name="subscription-extensions-list"></a>

**`$extensions.setSubscriptionFilter(filterJsonObject)`**  
Définit des filtres d'abonnement améliorés. Chaque événement de notification d'abonnement est évalué par rapport aux filtres d'abonnement fournis et envoie des notifications aux clients si tous les filtres répondent aux critères`true`. L'argument est `filterJsonObject` tel que décrit dans la section suivante.  
Vous pouvez utiliser cette méthode d'extension uniquement dans les modèles de mappage des réponses d'un résolveur d'abonnement.

**`$extensions.setSubscriptionInvalidationFilter(filterJsonObject)`**  
Définit les filtres d'invalidation des abonnements. Les filtres d'abonnement sont évalués par rapport à la charge utile d'invalidation, puis invalident un abonnement donné s'ils sont évalués à. `true` L'argument est `filterJsonObject` tel que décrit dans la section suivante.  
Vous pouvez utiliser cette méthode d'extension uniquement dans les modèles de mappage des réponses d'un résolveur d'abonnement.

**`$extensions.invalidateSubscriptions(invalidationJsonObject)`**  
Utilisé pour initier l'invalidation d'un abonnement suite à une mutation. L'argument est `invalidationJsonObject` tel que décrit dans la section suivante.  
Cette extension ne peut être utilisée que dans les modèles de mappage des réponses des résolveurs de mutations.  
Vous ne pouvez utiliser qu'au maximum cinq appels de `$extensions.invalidateSubscriptions()` méthode uniques dans une seule demande. Si vous dépassez cette limite, vous recevrez une erreur GraphQL.

## Argument : filterJsonObject
<a name="extensions-setSubscriptionInvalidationFilter"></a>

L'objet JSON définit des filtres d'abonnement ou d'invalidation. Il s'agit d'un ensemble de filtres dans un`filterGroup`. Chaque filtre est un ensemble de filtres individuels.

```
{
    "filterGroup": [
        {
           "filters" : [
                 {
                    "fieldName" : "userId",
                    "operator" : "eq",
                    "value" : 1
                }
           ]
           
        },
        {
           "filters" : [
                {
                    "fieldName" : "group",
                    "operator" : "in",
                    "value" : ["Admin", "Developer"]
                }
           ]
           
        }
    ]
}
```

Chaque filtre possède trois attributs : 
+ `fieldName`— Le champ du schéma GraphQL.
+ `operator`— Le type d'opérateur.
+ `value`— Les valeurs à comparer à la `fieldName` valeur de la notification d'abonnement.

Voici un exemple d'attribution de ces attributs :

```
{
 "fieldName" : "severity",
 "operator" : "le",
 "value" : $context.result.severity
}
```

### Domaine : FieldName
<a name="extensions-fieldName"></a>

Le type de chaîne `fieldName` fait référence à un champ défini dans le schéma GraphQL qui correspond `fieldName` à la charge utile de notification d'abonnement. Lorsqu'une correspondance est trouvée, le champ `value` du schéma GraphQL est comparé à celui du filtre `value` de notification d'abonnement. Dans l'exemple suivant, le `fieldName` filtre correspond au `service` champ défini dans un type GraphQL donné. Si la charge utile de notification contient un `service` champ avec un `value` équivalent à`AWS AppSync`, le filtre est évalué comme suit : `true`

```
{
 "fieldName" : "service",
 "operator" : "eq",
 "value" : "AWS AppSync"
}
```

### Champ : valeur
<a name="extensions-value"></a>

La valeur peut être d'un type différent en fonction de l'opérateur :
+ Nombre unique ou booléen
  + Exemples de chaînes :`"test"`, `"service"`
  + Exemples de chiffres :`1`,`2`, `45.75`
  + Exemples booléens :, `true` `false`
+ Paires de nombres ou de chaînes
  + Exemple de paire de chaînes :`["test1","test2"]`, `["start","end"]`
  + Exemple de paire de numéros :`[1,4]`,`[67,89]`, `[12.45, 95.45]`
+ Tableaux de nombres ou de chaînes
  + Exemple de tableau de chaînes : `["test1","test2","test3","test4","test5"]`
  + Exemple de tableau de nombres :`[1,2,3,4,5]`, `[12.11,46.13,45.09,12.54,13.89]`

### Domaine : opérateur
<a name="extensions-operator"></a>

Chaîne distinguant majuscules et minuscules avec les valeurs possibles suivantes : 


| 
| 
| Opérateur | Description | Types de valeurs possibles | 
| --- |--- |--- |
| eq | Égal à | entier, flottant, chaîne, booléen | 
| ne | Non égal à | entier, flottant, chaîne, booléen | 
| le | Inférieur ou égal à | entier, flottant, chaîne | 
| lt | Inférieur à | entier, flottant, chaîne | 
| gm | Supérieur ou égal à | entier, flottant, chaîne | 
| gt | Supérieur à | entier, flottant, chaîne | 
| contient | Vérifie la présence d'une sous-séquence ou d'une valeur dans l'ensemble. | entier, flottant, chaîne | 
| NE CONTIENT PAS | Vérifie l'absence de sous-séquence ou l'absence de valeur dans l'ensemble. | entier, flottant, chaîne | 
| Commence par | Vérifie la présence d'un préfixe. | chaîne | 
| in | Vérifie les éléments correspondants figurant dans la liste. | Tableau de nombres entiers, flottants ou chaînes | 
| notIn | Vérifie les éléments correspondants qui ne figurent pas dans la liste. | Tableau de nombres entiers, flottants ou chaînes | 
| between | Entre deux valeurs | entier, flottant, chaîne | 
| Contient n'importe quel | Contient des éléments communs | entier, flottant, chaîne | 

Le tableau suivant décrit comment chaque opérateur est utilisé dans la notification d'abonnement.

------
#### [ eq (equal) ]

L'`eq`opérateur évalue `true` si la valeur du champ de notification d'abonnement correspond et est strictement égale à la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `service` champ dont la valeur est équivalente à`AWS AppSync`.

**Types de valeurs possibles :** entier, flottant, chaîne, booléen

```
{
 "fieldName" : "service",
 "operator" : "eq",
 "value" : "AWS AppSync"
}
```

------
#### [ ne (not equal) ]

L'`ne`opérateur détermine `true` si la valeur du champ de notification d'abonnement est différente de la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `service` champ dont la valeur est différente de`AWS AppSync`.

**Types de valeurs possibles :** entier, flottant, chaîne, booléen

```
{
 "fieldName" : "service",
 "operator" : "ne",
 "value" : "AWS AppSync"
}
```

------
#### [ le (less or equal) ]

L'`le`opérateur détermine `true` si la valeur du champ de notification d'abonnement est inférieure ou égale à la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `size` champ dont la valeur est inférieure ou égale à`5`.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "size",
 "operator" : "le",
 "value" : 5
}
```

------
#### [ lt (less than) ]

L'`lt`opérateur détermine `true` si la valeur du champ de notification d'abonnement est inférieure à la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `size` champ dont la valeur est inférieure `5` à.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "size",
 "operator" : "lt",
 "value" : 5
}
```

------
#### [ ge (greater or equal) ]

L'`ge`opérateur détermine `true` si la valeur du champ de notification d'abonnement est supérieure ou égale à la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `size` champ dont la valeur est supérieure ou égale à`5`.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "size",
 "operator" : "ge",
 "value" : 5
}
```

------
#### [ gt (greater than) ]

L'`gt`opérateur détermine `true` si la valeur du champ de notification d'abonnement est supérieure à la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `size` champ dont la valeur est supérieure à`5`.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "size",
 "operator" : "gt",
 "value" : 5
}
```

------
#### [ contains ]

L'`contains`opérateur vérifie la présence d'une sous-chaîne, d'une sous-séquence ou d'une valeur dans un ensemble ou un élément unique. Un filtre avec l'`contains`opérateur détermine `true` si la valeur du champ de notification d'abonnement contient la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `seats` champ contenant la valeur `10` du tableau.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "seats",
 "operator" : "contains",
 "value" : 10
}
```

Dans un autre exemple, le filtre détermine `true` si la notification d'abonnement contient un `event` champ `launch` sous forme de sous-chaîne.

```
{
 "fieldName" : "event",
 "operator" : "contains",
 "value" : "launch"
}
```

------
#### [ notContains ]

L'`notContains`opérateur vérifie l'absence de sous-chaîne, de sous-séquence ou de valeur dans un ensemble ou un élément unique. Le filtre avec l'`notContains`opérateur détermine `true` si la valeur du champ de notification d'abonnement ne contient pas la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `seats` champ dans lequel la valeur du tableau ne contient pas la valeur`10`.

**Types de valeurs possibles :** entier, flottant, chaîne

```
{
 "fieldName" : "seats",
 "operator" : "notContains",
 "value" : 10
}
```

Dans un autre exemple, le filtre détermine `true` si la notification d'abonnement contient une valeur de `event` champ sans `launch` sa sous-séquence.

```
{
 "fieldName" : "event",
 "operator" : "notContains",
 "value" : "launch"
}
```

------
#### [ beginsWith ]

L'`beginsWith`opérateur vérifie la présence d'un préfixe dans une chaîne. Le filtre contenant l'`beginsWith`opérateur détermine `true` si la valeur du champ de notification d'abonnement commence par la valeur du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `service` champ dont la valeur commence `AWS` par.

**Type de valeur possible :** chaîne

```
{
 "fieldName" : "service",
 "operator" : "beginsWith",
 "value" : "AWS"
}
```

------
#### [ in ]

L'`in`opérateur vérifie les éléments correspondants dans un tableau. Le filtre contenant l'`in`opérateur détermine `true` si la valeur du champ de notification d'abonnement existe dans un tableau. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `severity` champ contenant l'une des valeurs présentes dans le tableau :`[1,2,3]`.

**Type de valeur possible :** tableau de nombres entiers, flottants ou chaînes

```
{
 "fieldName" : "severity",
 "operator" : "in",
 "value" : [1,2,3]
}
```

------
#### [ notIn ]

L'`notIn`opérateur vérifie s'il n'y a pas d'éléments manquants dans un tableau. Le filtre contenant l'`notIn`opérateur détermine `true` si la valeur du champ de notification d'abonnement n'existe pas dans le tableau. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `severity` champ contenant l'une des valeurs absentes du tableau :`[1,2,3]`.

**Type de valeur possible :** tableau de nombres entiers, flottants ou chaînes

```
{
 "fieldName" : "severity",
 "operator" : "notIn",
 "value" : [1,2,3]
}
```

------
#### [ between ]

L'`between`opérateur vérifie les valeurs comprises entre deux nombres ou chaînes. Le filtre contenant l'`between`opérateur détermine `true` si la valeur du champ de notification d'abonnement se situe entre la paire de valeurs du filtre. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `severity` champ contenant des valeurs`2`,`3`,`4`.

**Types de valeurs possibles :** paire d'entiers, de nombres flottants ou de chaînes

```
{
 "fieldName" : "severity",
 "operator" : "between",
 "value" : [1,5]
}
```

------
#### [ containsAny ]

L'`containsAny`opérateur vérifie la présence d'éléments communs dans les tableaux. Un filtre avec l'`containsAny`opérateur évalue `true` si l'intersection entre la valeur définie du champ de notification d'abonnement et la valeur définie du filtre n'est pas vide. Dans l'exemple suivant, le filtre détermine `true` si la notification d'abonnement contient un `seats` champ dont la valeur du tableau contient soit `10` ou`15`. Cela signifie que le filtre évaluera `true` si la valeur du `seats` champ de la notification d'abonnement est égale à `[10,11]` ou`[15,20,30]`.

**Types de valeurs possibles :** entier, flottant ou chaîne

```
{
 "fieldName" : "seats",
 "operator" : "containsAny",
 "value" : [10, 15]
}
```

------

### Logique AND
<a name="extensions-AND-logic"></a>

Vous pouvez combiner plusieurs filtres à l'aide de la logique AND en définissant plusieurs entrées dans l'`filters`objet du `filterGroup` tableau. Dans l'exemple suivant, les filtres évaluent `true` si la notification d'abonnement contient un `userId` champ avec une valeur équivalente à `1` ET une valeur de `group` champ égale à `Admin` ou`Developer`.

```
{
    "filterGroup": [
        {
           "filters" : [
                 {
                    "fieldName" : "userId",
                    "operator" : "eq",
                    "value" : 1
                },
                {
                    "fieldName" : "group",
                    "operator" : "in",
                    "value" : ["Admin", "Developer"]
                }
           ]
           
        }
    ]
}
```

### Logique OR
<a name="extensions-OR-logic"></a>

Vous pouvez combiner plusieurs filtres à l'aide de la logique OR en définissant plusieurs objets de filtre dans le `filterGroup` tableau. Dans l'exemple suivant, les filtres évaluent `true` si la notification d'abonnement contient un `userId` champ avec une valeur équivalente à `1` OU une valeur de `group` champ égale à `Admin` ou`Developer`.

```
{
    "filterGroup": [
        {
           "filters" : [
                 {
                    "fieldName" : "userId",
                    "operator" : "eq",
                    "value" : 1
                }
           ]
           
        },
        {
           "filters" : [
                {
                    "fieldName" : "group",
                    "operator" : "in",
                    "value" : ["Admin", "Developer"]
                }
           ]
           
        }
    ]
}
```

### Exceptions
<a name="extensions-exceptions"></a>

Notez que l'utilisation des filtres est soumise à plusieurs restrictions :
+ Dans l'`filters`objet, il peut y avoir un maximum de cinq `fieldName` éléments uniques par filtre. Cela signifie que vous pouvez combiner un maximum de cinq `fieldName` objets individuels à l'aide de la logique AND.
+ Il peut y avoir un maximum de vingt valeurs pour l'`containsAny`opérateur.
+ Il peut y avoir un maximum de cinq valeurs pour les `notIn` opérateurs `in` et.
+ Chaque chaîne peut comporter un maximum de 256 caractères.
+ Chaque comparaison de chaînes fait la distinction majuscules/minuscules.
+ Le filtrage des objets imbriqués permet d'obtenir jusqu'à cinq niveaux de filtrage imbriqués.
+ Chacun `filterGroup` peut en avoir un maximum de 10`filters`. Cela signifie que vous pouvez en combiner un maximum de 10 `filters` en utilisant la logique OR.
  + L'`in`opérateur est un cas particulier de la logique OR. Dans l'exemple suivant, il y en a deux `filters` :

    ```
    {
        "filterGroup": [
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "in",
                        "value" : ["Admin", "Developer"]
                    }
               ]  
            }
        ]
    }
    ```

    Le groupe de filtres précédent est évalué comme suit et est pris en compte dans le calcul de la limite maximale de filtres :

    ```
    {
        "filterGroup": [
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "eq",
                        "value" : "Admin"
                    }
               ]  
            },
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "eq",
                        "value" : "Developer"
                    }
               ]  
            }
        ]
    }
    ```

## Argument : invalidationJsonObject
<a name="extensions-invalidationJsonObject"></a>

`invalidationJsonObject`définit les éléments suivants :
+ `subscriptionField`— L'abonnement au schéma GraphQL à invalider. Un seul abonnement, défini sous la forme d'une chaîne dans le`subscriptionField`, est considéré comme invalide.
+ `payload`— Une liste de paires clé-valeur utilisée comme entrée pour invalider les abonnements si le filtre d'invalidation est évalué par rapport à leurs valeurs. `true`

  L'exemple suivant invalide les clients abonnés et connectés utilisant l'`onUserDelete`abonnement lorsque le filtre d'invalidation défini dans le résolveur d'abonnement est évalué par rapport à la valeur. `true` `payload`

  ```
  $extensions.invalidateSubscriptions({
          "subscriptionField": "onUserDelete",
          "payload": {
                  "group": "Developer"
                  "type" : "Full-Time"
        }
      })
  ```

# AWS AppSync référence du modèle de mappage du résolveur pour DynamoDB
<a name="resolver-mapping-template-reference-dynamodb"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

La fonction AWS AppSync DynamoDB vous permet d'utiliser [GraphQL](https://graphql.org) pour stocker et récupérer des données dans des tables Amazon DynamoDB existantes de votre compte en mappant une requête GraphQL entrante dans un appel DynamoDB, puis en mappant la réponse DynamoDB à GraphQL. Cette section décrit les gestionnaires de demandes et de réponses pour les opérations DynamoDB prises en charge :
+  [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.html)- La GetItem demande vous permet de demander à la fonction DynamoDB d'envoyer une GetItem demande à DynamoDB, de spécifier la clé de l'élément dans DynamoDB et d'utiliser une lecture cohérente ou non.
+  [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.html)- Le document de mappage des demandes vous permet de PutItem demander à la fonction DynamoDB d'envoyer une PutItem demande à DynamoDB et de spécifier la clé de l'élément dans DynamoDB, le contenu complet de l'élément (composé de clés et de valeurs d'attribut) et les conditions de réussite de l'opération.
+  [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.html)- La UpdateItem demande vous permet de demander à la fonction DynamoDB d'envoyer une UpdateItem demande à DynamoDB et de spécifier la clé de l'élément dans DynamoDB, une expression de mise à jour décrivant comment mettre à jour l'élément dans DynamoDB et les conditions de réussite de l'opération.
+  [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.html)- La DeleteItem demande vous permet de demander à la fonction DynamoDB d'envoyer une DeleteItem demande à DynamoDB, de spécifier la clé de l'élément dans DynamoDB et les conditions de réussite de l'opération.
+  [Requête](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-query.html) : l'objet de demande Query vous permet de demander au résolveur DynamoDB d'envoyer une demande de requête à DynamoDB et de spécifier l'expression clé, l'index à utiliser, les filtres supplémentaires, le nombre d'éléments à renvoyer, l'utilisation de lectures cohérentes, le sens de la requête (avant ou arrière) et les jetons de pagination.
+  [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-scan.html) : la demande Scan vous permet de demander à la fonction DynamoDB d'envoyer une demande de scan à DynamoDB et de spécifier un filtre pour exclure les résultats, l'index à utiliser, le nombre d'éléments à renvoyer, l'opportunité d'utiliser des lectures cohérentes, des jetons de pagination et des scans parallèles.
+  [Synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-sync.html) : l'objet de demande de synchronisation vous permet de récupérer tous les résultats d'une table DynamoDB, puis de ne recevoir que les données modifiées depuis votre dernière requête (le delta est mis à jour). Les demandes de synchronisation ne peuvent être effectuées que vers des sources de données DynamoDB versionnées. Vous pouvez spécifier un filtre pour exclure les résultats, le nombre d'éléments à renvoyer, les jetons de pagination et la date de début de votre dernière opération de synchronisation.
+  [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item.html)- L'objet de BatchGetItem requête vous permet de demander à la fonction DynamoDB d'envoyer une BatchGetItem demande à DynamoDB pour récupérer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de requête, vous devez spécifier les noms des tables à partir desquelles récupérer les éléments et les clés des éléments à récupérer dans chaque table.
+  [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item.html)- L'objet de BatchDeleteItem requête vous permet de demander à la fonction DynamoDB de BatchWriteItem demander à DynamoDB de supprimer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de requête, vous devez spécifier les noms des tables dont vous souhaitez supprimer les éléments et les clés des éléments à supprimer de chaque table.
+  [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item.html)- L'objet de BatchPutItem requête vous permet de demander à la fonction DynamoDB d'envoyer une BatchWriteItem demande à DynamoDB pour placer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de requête, vous devez spécifier les noms des tables dans lesquelles placer les éléments et les éléments complets à placer dans chaque table.
+  [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items.html)- L'objet de TransactGetItems requête vous permet de demander à la fonction DynamoDB d'envoyer une TransactGetItems demande à DynamoDB pour récupérer plusieurs éléments, potentiellement sur plusieurs tables. Pour cet objet de demande, vous devez spécifier le nom de table de chaque élément de demande à partir duquel l'élément doit être extrait et la clé de chaque élément de demande à extraire de chaque table.
+  [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- L'objet de TransactWriteItems requête vous permet de demander à la fonction DynamoDB de TransactWriteItems demander à DynamoDB d'écrire plusieurs éléments, éventuellement dans plusieurs tables. Pour cet objet de demande, vous devez spécifier le nom de table de destination de chaque élément de demande, l'opération de chaque élément de demande à effectuer et la clé de chaque élément de demande à écrire.
+  [Système de types (mappage des demandes)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.html) : découvrez comment la saisie DynamoDB est intégrée aux demandes. AWS AppSync 
+  [Système de types (mappage des réponses)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.html) : découvrez comment les types DynamoDB sont automatiquement convertis en GraphQL ou JSON dans une charge utile de réponse.
+  [Filtres](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-filter.html) - En savoir plus sur les filtres pour les opérations de recherche et de numérisation.
+  [Expressions de condition](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.html) : en savoir plus sur les expressions de condition pour PutItem UpdateItem, et les DeleteItem opérations.
+  [Expressions de conditions de transaction](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.html) - En savoir plus sur les expressions de conditions pour les TransactWriteItems opérations.
+  [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-projections.html) - Découvrez comment spécifier des attributs dans les opérations de lecture.

# GetItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-getitem"></a>

Le document de mappage des demandes vous permet de `GetItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `GetItem` demande à DynamoDB et de spécifier :
+ La clé de l'élément dans DynamoDB
+ S'il convient d'utiliser une lecture cohérente ou non

Le document de mappage `GetItem` a la structure suivante :

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true,
    "projection" : {
        ...
    }
}
```

Les champs sont définis comme suit :

## GetItem champs
<a name="getitem-list"></a>

### GetItem liste des champs
<a name="getitem-list-col"></a>

 **`version`**   
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

 **`operation`**   
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `GetItem`, ce champ doit être défini sur `GetItem`. Cette valeur est obligatoire.

 **`key`**   
La clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.

 **`consistentRead`**   
S'il faut ou non effectuer une lecture très cohérente avec DynamoDB. Ce champ est facultatif et `false` est la valeur définie par défaut.

**`projection`**  
Projection utilisée pour spécifier les attributs à renvoyer par l'opération DynamoDB. Pour plus d'informations sur les projections, voir [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections). Ce champ est facultatif.

L'élément renvoyé par DynamoDB est automatiquement converti en types primitifs GraphQL et JSON, et est disponible dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Exemple
<a name="example"></a>

L'exemple suivant est un modèle de mappage pour une requête GraphQL : `getThing(foo: String!, bar: String!)`

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "consistentRead" : true
}
```

Pour de plus amples informations sur l'API de DynamoDB `GetItem`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).

# PutItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-putitem"></a>

Le document de mappage des demandes vous permet de `PutItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `PutItem` demande à DynamoDB et de spécifier les éléments suivants :
+ La clé de l'élément dans DynamoDB
+ Contenu complet de l'élément (composé de `key` et de `attributeValues`)
+ Conditions de réussite de l'opération

Le document de mappage `PutItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "PutItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    },
    "_version" : 1
}
```

Les champs sont définis comme suit :

## PutItem champs
<a name="putitem-list"></a>

### PutItem liste des champs
<a name="putitem-list-col"></a>

 **`version`**   
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

 **`operation`**   
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `PutItem`, ce champ doit être défini sur `PutItem`. Cette valeur est obligatoire.

 **`key`**   
La clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.

 **`attributeValues`**   
Le reste des attributs de l'élément doit être placé dans DynamoDB. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Ce champ est facultatif.

 **`condition`**   
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `PutItem` remplace toute entrée existante pour cet élément. Pour plus d'informations sur les conditions, consultez la section [Expressions de condition](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Cette valeur est facultative.

 **`_version`**   
Valeur numérique représentant la dernière version connue d'un élément. Cette valeur est facultative. Ce champ est utilisé pour la *détection de conflits* et n'est pris en charge que sur les sources de données versionnées.

**`customPartitionKey`**  
Lorsqu'elle est activée, cette valeur de chaîne modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le contrôle des versions a été activé (pour plus d'informations, voir [Détection des conflits et synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*). Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. Ce champ est facultatif.

**`populateIndexFields`**  
Valeur booléenne qui, lorsqu'elle est activée en **même temps que le `customPartitionKey`**, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. Pour plus d'informations, consultez la section [Détection et synchronisation des conflits](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*. Ce champ est facultatif. 

L'élément écrit dans DynamoDB est automatiquement converti en types primitifs GraphQL et JSON et est disponible dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Exemple 1
<a name="example-1"></a>

L'exemple suivant est un modèle de mappage pour une mutation GraphQL. `updateThing(foo: String!, bar: String!, name: String!, version: Int!)`

S'il n'existe aucun élément avec la clé spécifiée, il est créé. S'il existe déjà un élément avec la clé spécifiée, il est remplacé.

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "attributeValues" : {
        "name"    : $util.dynamodb.toDynamoDBJson($ctx.args.name),
        "version" : $util.dynamodb.toDynamoDBJson($ctx.args.version)
    }
}
```

## Exemple 2
<a name="example-2"></a>

L'exemple suivant est un modèle de mappage pour une mutation GraphQL. `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)`

Cet exemple vérifie que le champ de l'élément actuellement dans DynamoDB est défini `version` sur. `expectedVersion`

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "attributeValues" : {
        "name"    : $util.dynamodb.toDynamoDBJson($ctx.args.name),
        #set( $newVersion = $context.arguments.expectedVersion + 1 )
        "version" : $util.dynamodb.toDynamoDBJson($newVersion)
    },
    "condition" : {
        "expression" : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
        }
    }
}
```

Pour de plus amples informations sur l'API de DynamoDB `PutItem`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).

# UpdateItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem"></a>

Le document de mappage des demandes vous permet de `UpdateItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `UpdateItem` demande à DynamoDB et de spécifier les éléments suivants :
+ La clé de l'élément dans DynamoDB
+ Expression de mise à jour décrivant comment mettre à jour l'élément dans DynamoDB
+ Conditions de réussite de l'opération

Le document de mappage `UpdateItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "UpdateItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "update" : {
        "expression" : "someExpression",
        "expressionNames" : {
           "#foo" : "foo"
       },
       "expressionValues" : {
           ":bar" : ... typed value
       }
    },
    "condition" : {
        ...
    },
    "_version" : 1
}
```

Les champs sont définis comme suit :

## UpdateItem champs
<a name="updateitem-list"></a>

### UpdateItem liste des champs
<a name="updateitem-list-col"></a>

 **`version`**   
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

 **`operation`**   
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `UpdateItem`, ce champ doit être défini sur `UpdateItem`. Cette valeur est obligatoire.

 **`key`**   
La clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la spécification d'une « valeur saisie », consultez [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.

 **`update`**   
La `update` section vous permet de spécifier une expression de mise à jour qui décrit comment mettre à jour l'élément dans DynamoDB. Pour plus d'informations sur la façon d'écrire des expressions de mise à jour, consultez la documentation [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Cette section est obligatoire.  
La section `update` possède trois composants :    
** `expression` **  
Expression de mise à jour. Cette valeur est obligatoire.  
** `expressionNames` **  
Substituts des espaces réservés de *nom* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé utilisé dans le`expression`, et la valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de nom des attributs de l'expression utilisés dans l'`expression`.  
** `expressionValues` **  
Substituts des espaces réservés de *valeur* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de valeur utilisé dans l'`expression`, et la valeur doit être typée. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cela doit être spécifié. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de valeur des attributs de l'expression utilisés dans l'`expression`.

 **`condition`**   
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `UpdateItem` met à jour l'entrée existante quel que soit son état actuel. Pour plus d'informations sur les conditions, consultez la section [Expressions de condition](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Cette valeur est facultative.

 **`_version`**   
Valeur numérique représentant la dernière version connue d'un élément. Cette valeur est facultative. Ce champ est utilisé pour la *détection de conflits* et n'est pris en charge que sur les sources de données versionnées.

**`customPartitionKey`**  
Lorsqu'elle est activée, cette valeur de chaîne modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le contrôle des versions a été activé (pour plus d'informations, voir [Détection des conflits et synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*). Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. Ce champ est facultatif.

**`populateIndexFields`**  
Valeur booléenne qui, lorsqu'elle est activée en **même temps que le `customPartitionKey`**, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. Pour plus d'informations, consultez la section [Détection et synchronisation des conflits](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*. Ce champ est facultatif.

L'élément mis à jour dans DynamoDB est automatiquement converti en types primitifs GraphQL et JSON et est disponible dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Exemple 1
<a name="id3"></a>

L'exemple suivant est un modèle de mappage pour la mutation GraphQL. `upvote(id: ID!)`

Dans cet exemple, les champs et d'un élément de DynamoDB sont `upvotes` incrémentés de `version` 1.

```
{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "update" : {
        "expression" : "ADD #votefield :plusOne, version :plusOne",
        "expressionNames" : {
            "#votefield" : "upvotes"
        },
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}
```

## Exemple 2
<a name="id4"></a>

L'exemple suivant est un modèle de mappage pour une mutation GraphQL. `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`

Il s'agit d'un exemple complexe qui inspecte les arguments et génère dynamiquement l'expression de mise à jour incluant uniquement les arguments qui ont été fournis par le client. Par exemple, si `title` et `author` sont omis, ils ne sont pas mis à jour. Si un argument est spécifié mais que sa valeur l'est`null`, ce champ est supprimé de l'objet dans DynamoDB. Enfin, l'opération comporte une condition qui vérifie si le champ de l'élément actuellement dans DynamoDB est `version` défini comme suit : `expectedVersion`

```
{
    "version" : "2017-02-28",

    "operation" : "UpdateItem",

    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },

    ## Set up some space to keep track of things we're updating **
    #set( $expNames  = {} )
    #set( $expValues = {} )
    #set( $expSet = {} )
    #set( $expAdd = {} )
    #set( $expRemove = [] )

    ## Increment "version" by 1 **
    $!{expAdd.put("version", ":newVersion")}
    $!{expValues.put(":newVersion", { "N" : 1 })}

    ## Iterate through each argument, skipping "id" and "expectedVersion" **
    #foreach( $entry in $context.arguments.entrySet() )
        #if( $entry.key != "id" && $entry.key != "expectedVersion" )
            #if( (!$entry.value) && ("$!{entry.value}" == "") )
                ## If the argument is set to "null", then remove that attribute from the item in DynamoDB **

                #set( $discard = ${expRemove.add("#${entry.key}")} )
                $!{expNames.put("#${entry.key}", "$entry.key")}
            #else
                ## Otherwise set (or update) the attribute on the item in DynamoDB **

                $!{expSet.put("#${entry.key}", ":${entry.key}")}
                $!{expNames.put("#${entry.key}", "$entry.key")}

                #if( $entry.key == "ups" || $entry.key == "downs" )
                    $!{expValues.put(":${entry.key}", { "N" : $entry.value })}
                #else
                    $!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
                #end
            #end
        #end
    #end

    ## Start building the update expression, starting with attributes we're going to SET **
    #set( $expression = "" )
    #if( !${expSet.isEmpty()} )
        #set( $expression = "SET" )
        #foreach( $entry in $expSet.entrySet() )
            #set( $expression = "${expression} ${entry.key} = ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes we're going to ADD **
    #if( !${expAdd.isEmpty()} )
        #set( $expression = "${expression} ADD" )
        #foreach( $entry in $expAdd.entrySet() )
            #set( $expression = "${expression} ${entry.key} ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes we're going to REMOVE **
    #if( !${expRemove.isEmpty()} )
        #set( $expression = "${expression} REMOVE" )

        #foreach( $entry in $expRemove )
            #set( $expression = "${expression} ${entry}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
    "update" : {
        "expression" : "${expression}"
        #if( !${expNames.isEmpty()} )
            ,"expressionNames" : $utils.toJson($expNames)
        #end
        #if( !${expValues.isEmpty()} )
            ,"expressionValues" : $utils.toJson($expValues)
        #end
    },

    "condition" : {
        "expression"       : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($ctx.args.expectedVersion)
        }
    }
}
```

Pour de plus amples informations sur l'API de DynamoDB `UpdateItem`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).

# DeleteItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem"></a>

Le document de mappage des demandes vous permet de `DeleteItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `DeleteItem` demande à DynamoDB et de spécifier les éléments suivants :
+ La clé de l'élément dans DynamoDB
+ Conditions de réussite de l'opération

Le document de mappage `DeleteItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "DeleteItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "condition" : {
        ...
    },
    "_version" : 1
}
```

Les champs sont définis comme suit :

## DeleteItem champs
<a name="deleteitem-list"></a>

### DeleteItem liste des champs
<a name="deleteitem-list-col"></a>

** `version` **  
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `DeleteItem`, ce champ doit être défini sur `DeleteItem`. Cette valeur est obligatoire.

** `key` **  
La clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la spécification d'une « valeur saisie », consultez [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.

** `condition` **  
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `DeleteItem` supprime un élément existant quel que soit son état actuel. Pour plus d'informations sur les conditions, consultez la section [Expressions de condition](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Cette valeur est facultative.

** `_version` **  
Valeur numérique représentant la dernière version connue d'un élément. Cette valeur est facultative. Ce champ est utilisé pour la *détection de conflits* et n'est pris en charge que sur les sources de données versionnées.

**`customPartitionKey`**  
Lorsqu'elle est activée, cette valeur de chaîne modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le contrôle des versions a été activé (pour plus d'informations, voir [Détection des conflits et synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*). Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. Ce champ est facultatif.

**`populateIndexFields`**  
Valeur booléenne qui, lorsqu'elle est activée en **même temps que le `customPartitionKey`**, crée de nouvelles entrées pour chaque enregistrement de la table de synchronisation delta, en particulier dans les colonnes `gsi_ds_pk` et`gsi_ds_sk`. Pour plus d'informations, consultez la section [Détection et synchronisation des conflits](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) dans le *manuel du AWS AppSync développeur*. Ce champ est facultatif. 

L'élément supprimé de DynamoDB est automatiquement converti en types primitifs GraphQL et JSON et est disponible dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Exemple 1
<a name="id6"></a>

L'exemple suivant est un modèle de mappage pour une mutation GraphQL. `deleteItem(id: ID!)` S'il existe déjà un élément avec cet ID, il est supprimé.

```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}
```

## Exemple 2
<a name="id7"></a>

L'exemple suivant est un modèle de mappage pour une mutation GraphQL. `deleteItem(id: ID!, expectedVersion: Int!)` S'il existe déjà un élément avec cet ID, il est supprimé, mais uniquement si son champ `version` est défini sur `expectedVersion` :

```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "condition" : {
        "expression"       : "attribute_not_exists(id) OR version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
        }
    }
}
```

Pour de plus amples informations sur l'API de DynamoDB `DeleteItem`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).

# Query
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-query"></a>

Le document de mappage des demandes vous permet de `Query` demander au résolveur AWS AppSync DynamoDB d'envoyer une `Query` demande à DynamoDB et de spécifier les éléments suivants :
+ Expression de la clé
+ Quel index utiliser
+ Tout filtre supplémentaire
+ Combien d'articles renvoyer
+ S'il convient d'utiliser une lecture cohérente
+ Sens de la requête (vers l'avant ou l'arrière)
+ Jeton de pagination

Le document de mappage `Query` a la structure suivante :

```
{
    "version" : "2017-02-28",
    "operation" : "Query",
    "query" : {
        "expression" : "some expression",
        "expressionNames" : {
            "#foo" : "foo"
        },
        "expressionValues" : {
            ":bar" : ... typed value
        }
    },
    "index" : "fooIndex",
    "nextToken" : "a pagination token",
    "limit" : 10,
    "scanIndexForward" : true,
    "consistentRead" : false,
    "select" : "ALL_ATTRIBUTES" | "ALL_PROJECTED_ATTRIBUTES" | "SPECIFIC_ATTRIBUTES",
    "filter" : {
        ...
    },
    "projection" : {
        ...
    }
}
```

Les champs sont définis comme suit :

## Champs de requête
<a name="query-list"></a>

### Liste des champs de requête
<a name="query-list-col"></a>

** `version` **  
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `Query`, ce champ doit être défini sur `Query`. Cette valeur est obligatoire.

** `query` **  
Cette `query` section vous permet de spécifier une expression de condition clé qui décrit les éléments à récupérer depuis DynamoDB. Pour plus d'informations sur la façon d'écrire des expressions de conditions clés, consultez la documentation [ KeyConditions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Cette section doit être spécifiée.    
** `expression` **  
Expression de la requête. Ce champ doit être spécifié.  
** `expressionNames` **  
Substituts des espaces réservés de *nom* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé utilisé dans le`expression`, et la valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de nom des attributs de l'expression utilisés dans l'`expression`.  
** `expressionValues` **  
Substituts des espaces réservés de *valeur* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de valeur utilisé dans l'`expression`, et la valeur doit être typée. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de valeur des attributs de l'expression utilisés dans l'`expression`.

** `filter` **  
Filtre supplémentaire qui peut être utilisé pour filtrer les résultats de DynamoDB avant qu'ils soient renvoyés. Pour plus d'informations sur les filtres, consultez [Filters (Filtres)](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Ce champ est facultatif.

** `index` **  
Nom de l'index à interroger. L'opération de requête DynamoDB vous permet de rechercher une clé de hachage sur les index secondaires locaux et les index secondaires globaux en plus de l'index de clé primaire. Si cela est spécifié, cela indique à DynamoDB d'interroger l'index spécifié. Si elle ne l'est pas, l'index de clé primaire est interrogé.

** `nextToken` **  
Jeton de pagination pour continuer une requête précédente. Il a été obtenu à partir d'une requête précédente. Ce champ est facultatif.

** `limit` **  
Nombre maximum d'éléments à évaluer (pas nécessairement le nombre d'éléments correspondants). Ce champ est facultatif.

** `scanIndexForward` **  
Valeur booléenne indiquant s'il convient d'interroger vers l'avant ou vers l'arrière. Ce champ est facultatif et contient `true` par défaut.

** `consistentRead` **  
Un booléen indiquant s'il faut utiliser des lectures cohérentes lors de l'interrogation de DynamoDB. Ce champ est facultatif et contient `false` par défaut.

** `select` **  
Par défaut, le résolveur AWS AppSync DynamoDB renvoie uniquement les attributs projetés dans l'index. Si un plus grand nombre d'attributs est requis, vous pouvez définir ce champ. Ce champ est facultatif. Les valeurs prises en charge sont :    
** `ALL_ATTRIBUTES` **  
Renvoie tous les attributs de l'élément depuis la table ou l'index spécifié. Si vous interrogez un index secondaire local, DynamoDB extrait l'élément entier de la table parent pour chaque élément correspondant de l'index. Si l'index est configuré de façon à projeter tous les attributs de l'élément, toutes les données peuvent être obtenues à partir de l'index secondaire local, et aucune extraction n'est nécessaire.  
** `ALL_PROJECTED_ATTRIBUTES` **  
Autorisé seulement lorsque vous interrogez un index. Extrait tous les attributs qui ont été projetés dans l'index. Si l'index est configuré de façon à projeter tous les attributs, la valeur renvoyée revient à spécifier `ALL_ATTRIBUTES`.  
**`SPECIFIC_ATTRIBUTES`**  
Renvoie uniquement les attributs répertoriés dans le `projection` « s `expression` ». Cette valeur de retour revient à spécifier les « `projection` s » `expression` sans spécifier de valeur pour`Select`.

**`projection`**  
Projection utilisée pour spécifier les attributs à renvoyer par l'opération DynamoDB. Pour plus d'informations sur les projections, voir [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections). Ce champ est facultatif.

Les résultats de DynamoDB sont automatiquement convertis en types primitifs GraphQL et JSON et sont disponibles dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

Les résultats ont la structure suivante :

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10
}
```

Les champs sont définis comme suit :

** `items` **  
Liste contenant les éléments renvoyés par la requête DynamoDB.

** `nextToken` **  
S'il peut y avoir plusieurs résultats, `nextToken` contient un jeton de pagination que vous pouvez utiliser dans une autre requête. Notez que cela AWS AppSync chiffre et masque le jeton de pagination renvoyé par DynamoDB. Cela empêche que les données provenant de votre table ne soient accidentellement communiquées au mandataire. Notez également que ces jetons de pagination ne peuvent pas être utilisés dans les différents résolveurs.

** `scannedCount` **  
Nombre d'éléments correspondant à l'expression de condition de requête, avant qu'une expression de filtre (si elle est présente) ne soit appliquée.

## Exemple
<a name="id9"></a>

L'exemple suivant est un modèle de mappage pour une requête GraphQL. `getPosts(owner: ID!)`

Dans cet exemple, un index secondaire global sur une table est interrogé afin de renvoyer toutes les publications détenues par l'ID spécifié.

```
{
    "version" : "2017-02-28",
    "operation" : "Query",
    "query" : {
        "expression" : "ownerId = :ownerId",
        "expressionValues" : {
            ":ownerId" : $util.dynamodb.toDynamoDBJson($context.arguments.owner)
        }
    },
    "index" : "owner-index"
}
```

Pour de plus amples informations sur l'API de DynamoDB `Query`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).

# Analyser
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-scan"></a>

Le document de mappage des demandes vous permet de `Scan` demander au résolveur AWS AppSync DynamoDB d'envoyer une `Scan` demande à DynamoDB et de spécifier les éléments suivants :
+ Filtre pour exclure des résultats
+ Quel index utiliser
+ Combien d'articles renvoyer
+ S'il convient d'utiliser une lecture cohérente
+ Jeton de pagination
+ Analyses parallèles

Le document de mappage `Scan` a la structure suivante :

```
{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "index" : "fooIndex",
    "limit" : 10,
    "consistentRead" : false,
    "nextToken" : "aPaginationToken",
    "totalSegments" : 10,
    "segment" : 1,
    "filter" : {
        ...
    },
    "projection" : {
        ...
    }
}
```

Les champs sont définis comme suit :

## Numériser les champs
<a name="scan-list"></a>

### Numériser la liste des champs
<a name="scan-list-col"></a>

** `version` **  
Version de la définition du modèle. `2017-02-28` et `2018-05-29` sont actuellement prises en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `Scan`, ce champ doit être défini sur `Scan`. Cette valeur est obligatoire.

** `filter` **  
Filtre qui peut être utilisé pour filtrer les résultats de DynamoDB avant qu'ils ne soient renvoyés. Pour plus d'informations sur les filtres, consultez [Filters (Filtres)](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Ce champ est facultatif.

** `index` **  
Nom de l'index à interroger. L'opération de requête DynamoDB vous permet de rechercher une clé de hachage sur les index secondaires locaux et les index secondaires globaux en plus de l'index de clé primaire. Si cela est spécifié, cela indique à DynamoDB d'interroger l'index spécifié. Si elle ne l'est pas, l'index de clé primaire est interrogé.

** `limit` **  
Nombre maximal d'éléments à évaluer simultanément. Ce champ est facultatif.

** `consistentRead` **  
Un booléen qui indique s'il faut utiliser des lectures cohérentes lors de l'interrogation de DynamoDB. Ce champ est facultatif et contient `false` par défaut.

** `nextToken` **  
Jeton de pagination pour continuer une requête précédente. Il a été obtenu à partir d'une requête précédente. Ce champ est facultatif.

** `select` **  
Par défaut, le résolveur AWS AppSync DynamoDB renvoie uniquement les attributs projetés dans l'index. Si un plus grand nombre d'attributs est requis, ce champ peut être défini. Ce champ est facultatif. Les valeurs prises en charge sont :    
** `ALL_ATTRIBUTES` **  
Renvoie tous les attributs de l'élément depuis la table ou l'index spécifié. Si vous interrogez un index secondaire local, DynamoDB extrait l'élément entier de la table parent pour chaque élément correspondant de l'index. Si l'index est configuré de façon à projeter tous les attributs de l'élément, toutes les données peuvent être obtenues à partir de l'index secondaire local, et aucune extraction n'est nécessaire.  
** `ALL_PROJECTED_ATTRIBUTES` **  
Autorisé seulement lorsque vous interrogez un index. Extrait tous les attributs qui ont été projetés dans l'index. Si l'index est configuré de façon à projeter tous les attributs, la valeur renvoyée revient à spécifier `ALL_ATTRIBUTES`.  
**`SPECIFIC_ATTRIBUTES`**  
Renvoie uniquement les attributs répertoriés dans le `projection` « s `expression` ». Cette valeur de retour revient à spécifier les « `projection` s » `expression` sans spécifier de valeur pour`Select`.

** `totalSegments` **  
Nombre de segments pour partitionner la table lors de l'exécution d'une analyse parallèle. Ce champ est facultatif, mais doit être spécifié si `segment` est spécifié.

** `segment` **  
Segment de table de cette opération lorsque vous effectuez une analyse parallèle. Ce champ est facultatif, mais doit être spécifié si `totalSegments` est spécifié.

**`projection`**  
Projection utilisée pour spécifier les attributs à renvoyer par l'opération DynamoDB. Pour plus d'informations sur les projections, voir [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections). Ce champ est facultatif.

Les résultats renvoyés par le scan DynamoDB sont automatiquement convertis en types primitifs GraphQL et JSON et sont disponibles dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

Les résultats ont la structure suivante :

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10
}
```

Les champs sont définis comme suit :

** `items` **  
Liste contenant les éléments renvoyés par le scan DynamoDB.

** `nextToken` **  
S'il peut y avoir plus de résultats, `nextToken` contient un jeton de pagination que vous pouvez utiliser dans une autre demande. AWS AppSync chiffre et masque le jeton de pagination renvoyé par DynamoDB. Cela empêche que les données provenant de votre table ne soient accidentellement communiquées au mandataire. D'autre part, ces jetons de pagination ne peuvent pas être utilisés dans différents résolveurs.

** `scannedCount` **  
Nombre d'éléments récupérés par DynamoDB avant l'application d'une expression de filtre (le cas échéant).

## Exemple 1
<a name="id11"></a>

L'exemple suivant est un modèle de mappage pour la requête GraphQL :. `allPosts`

Dans cet exemple, toutes les entrées de la table sont renvoyées.

```
{
    "version" : "2017-02-28",
    "operation" : "Scan"
}
```

## Exemple 2
<a name="id12"></a>

L'exemple suivant est un modèle de mappage pour la requête GraphQL :. `postsMatching(title: String!)`

Dans cet exemple, toutes les entrées de la table sont renvoyées lorsque le titre commence par l'argument `title`.

```
{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "filter" : {
        "expression" : "begins_with(title, :title)",
        "expressionValues" : {
            ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
        },
    }
}
```

Pour de plus amples informations sur l'API de DynamoDB `Scan`, veuillez consulter la [Documentation sur les API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).

# Sync
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-sync"></a>

Le document de mappage des `Sync` demandes vous permet de récupérer tous les résultats d'une table DynamoDB, puis de ne recevoir que les données modifiées depuis votre dernière requête (le delta est mis à jour). `Sync`les demandes ne peuvent être adressées qu'à des sources de données DynamoDB versionnées. Vous pouvez spécifier les éléments suivants :
+ Filtre pour exclure des résultats
+ Combien d'articles renvoyer
+ Jeton de pagination.
+ Lorsque votre dernière opération `Sync` a été lancée

Le document de mappage `Sync` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "Sync",
    "basePartitionKey": "Base Tables PartitionKey",
    "deltaIndexName": "delta-index-name",
    "limit" : 10,
    "nextToken" : "aPaginationToken",
    "lastSync" :  1550000000000,
    "filter" : {
        ...
    }
}
```

Les champs sont définis comme suit :

## Synchroniser les champs
<a name="sync-list"></a>

### Liste des champs de synchronisation
<a name="sync-list-col"></a>

** `version` **  
Version de la définition du modèle. `2018-05-29` est le seul à être pris en charge actuellement. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération `Sync`, ce champ doit être défini sur `Sync`. Cette valeur est obligatoire.

** `filter` **  
Filtre qui peut être utilisé pour filtrer les résultats de DynamoDB avant qu'ils ne soient renvoyés. Pour plus d'informations sur les filtres, consultez [Filters (Filtres)](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Ce champ est facultatif.

** `limit` **  
Nombre maximal d'éléments à évaluer simultanément. Ce champ est facultatif. Si cette option est omise, la limite par défaut sera définie sur `100` éléments. La valeur maximale de ce champ est `1000` éléments.

** `nextToken` **  
Jeton de pagination pour continuer une requête précédente. Il a été obtenu à partir d'une requête précédente. Ce champ est facultatif.

** `lastSync` **  
Le moment, en millisecondes Epoch, où la dernière opération `Sync` réussie a commencé. Si spécifié, seuls les éléments qui ont changé après `lastSync` sont retournés. Ce champ est facultatif et ne doit être renseigné qu'après avoir récupéré toutes les pages d'une opération `Sync` initiale. Si cette option est omise, les résultats de la table *Base* seront retournés, sinon les résultats de la table *Delta* seront retournés.

**`basePartitionKey`**  
La clé de partition de la table de *base* utilisée lors de l'exécution d'une `Sync` opération. Ce champ permet d'effectuer une `Sync` opération lorsque la table utilise une clé de partition personnalisée. Il s'agit d'un champ facultatif.

**`deltaIndexName`**  
L'index utilisé pour l'`Sync`opération. Cet index est nécessaire pour permettre une `Sync` opération sur l'ensemble de la table delta store lorsque la table utilise une clé de partition personnalisée. L'`Sync`opération sera effectuée sur le GSI (créé sur `gsi_ds_pk` et`gsi_ds_sk`). Ce champ est facultatif.

Les résultats renvoyés par la synchronisation DynamoDB sont automatiquement convertis en types primitifs GraphQL et JSON et sont disponibles dans le contexte de mappage (). `$context.result`

Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappage des réponses).

Pour plus d'informations sur les modèles de mappage des réponses, consultez la section [Vue d'ensemble des modèles de mappage Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

Les résultats ont la structure suivante :

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10,
    startedAt = 1550000000000
}
```

Les champs sont définis comme suit :

** `items` **  
Liste contenant les éléments renvoyés par la synchronisation.

** `nextToken` **  
S'il peut y avoir plus de résultats, `nextToken` contient un jeton de pagination que vous pouvez utiliser dans une autre demande. AWS AppSync chiffre et masque le jeton de pagination renvoyé par DynamoDB. Cela empêche que les données provenant de votre table ne soient accidentellement communiquées au mandataire. D'autre part, ces jetons de pagination ne peuvent pas être utilisés dans différents résolveurs.

** `scannedCount` **  
Nombre d'éléments récupérés par DynamoDB avant l'application d'une expression de filtre (le cas échéant).

** `startedAt` **  
Le moment, en millisecondes Epoch, où l'opération de synchronisation a commencé, que vous pouvez stocker localement et utiliser dans une autre requête comme argument `lastSync`. Si un jeton de pagination a été inclus dans la requête, cette valeur sera la même que celle renvoyée par la requête pour la première page de résultats.

## Exemple
<a name="id14"></a>

L'exemple suivant est un modèle de mappage pour la requête GraphQL :. `syncPosts(nextToken: String, lastSync: AWSTimestamp)`

Dans cet exemple, si `lastSync` est omis, toutes les entrées de la table de base sont renvoyées. Si `lastSync` est fourni, seules les entrées de la table de synchronisation delta qui ont changé depuis `lastSync` sont renvoyées.

```
{
    "version" : "2018-05-29",
    "operation" : "Sync",
    "limit": 100,
    "nextToken": $util.toJson($util.defaultIfNull($ctx.args.nextToken, null)),
    "lastSync": $util.toJson($util.defaultIfNull($ctx.args.lastSync, null))
}
```

# BatchGetItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item"></a>

Le document de mappage des demandes vous permet de `BatchGetItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `BatchGetItem` demande à DynamoDB pour récupérer plusieurs éléments, éventuellement sur plusieurs tables. Pour ce modèle de requête, vous devez spécifier les valeurs suivantes :
+ Les noms de tables à partir desquels récupérer les éléments
+ Les clés des éléments à récupérer dans chaque table

Les limites `BatchGetItem` DynamoDB s'appliquent et **aucune expression de condition** ne peut être fournie.

Le document de mappage `BatchGetItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "BatchGetItem",
    "tables" : {
        "table1": {
           "keys": [
              ## Item to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              },
              ## Item2 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              }
            ],
            "consistentRead": true|false,            
            "projection" : {
                 ...
            }
        },
        "table2": {
           "keys": [
              ## Item3 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              },
              ## Item4 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              }
            ],
            "consistentRead": true|false,
            "projection" : {
                 ...
            }
        }
    }
}
```

Les champs sont définis comme suit :

## BatchGetItem champs
<a name="BatchGetItem-list"></a>

### BatchGetItem liste des champs
<a name="BatchGetItem-list-col"></a>

** `version` **  
Version de la définition du modèle. Seule la clause `2018-05-29` est prise en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `BatchGetItem`, ce champ doit être défini sur `BatchGetItem`. Cette valeur est obligatoire.

** `tables` **  
Les tables DynamoDB à partir desquelles récupérer les éléments. La valeur est une carte où les noms de table sont spécifiés en tant que clés de la carte. Vous devez fournir au moins une table. Cette valeur `tables` est obligatoire.    
** `keys` **  
Liste des clés DynamoDB représentant la clé primaire des éléments à récupérer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)  
** `consistentRead` **  
S'il faut utiliser une lecture cohérente lors de l'exécution d'une *GetItem*opération. Cette valeur est facultative et est définie comme *faux* par défaut.  
**`projection`**  
Projection utilisée pour spécifier les attributs à renvoyer par l'opération DynamoDB. Pour plus d'informations sur les projections, voir [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections). Ce champ est facultatif.

Objets à mémoriser :
+ Si un élément n'a pas été récupéré à partir de la table, un élément *null* s'affiche dans le bloc de données pour cette table.
+ Les résultats d'invocation sont triés par table, en fonction de l'ordre dans lequel ils ont été fournis dans le modèle de mappage des demandes.
+ Chaque `Get` commande contenue dans a `BatchGetItem` est atomique, mais un lot peut être partiellement traité. Si un lot est traité partiellement en raison d'une erreur, les clés non traitées sont renvoyées dans le cadre du résultat de l'appel dans le bloc *unprocessedKeys*.
+  `BatchGetItem` est limité à 100 clés.

Pour l'exemple de modèle de mappage de requête suivant :

```
{
  "version": "2018-05-29",
  "operation": "BatchGetItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          }
        }
    ],
  }
}
```

Le résultat de l'appel disponible dans `$ctx.result` est le suivant :

```
{
   "data": {
     "authors": [null],
     "posts": [
        # Was retrieved
        {
          "author_id": "a1",
          "post_id": "p2",
          "post_title": "title",
          "post_description": "description",
        }
     ]
   },
   "unprocessedKeys": {
     "authors": [
        # This item was not processed due to an error
        {
          "author_id": "a1"
        }
      ],
     "posts": []
   }
}
```

`$ctx.error` contient des détails sur l'erreur. Les **données** clés, **unprocessedKeys** et la clé de chaque table fournie dans le modèle de mappage de requête sont assurés d'être présents dans le résultat de l'appel. Les éléments ayant été supprimés apparaissent dans le bloc de **données**. Les éléments qui n'ont pas été traités sont marqués comme *null* dans le bloc de données et sont placés dans le bloc **unprocessedKeys**.

Pour un exemple plus complet, suivez le didacticiel DynamoDB Batch [avec ici AppSync Tutoriel : Résolveurs de lots DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).

# BatchDeleteItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item"></a>

Le document de mappage des demandes vous permet de `BatchDeleteItem` demander au résolveur AWS AppSync DynamoDB de `BatchWriteItem` demander à DynamoDB de supprimer plusieurs éléments, éventuellement sur plusieurs tables. Pour ce modèle de requête, vous devez spécifier les valeurs suivantes :
+ Les noms de tables à partir desquels supprimer les éléments
+ Les clés des éléments à supprimer dans chaque table

Les limites `BatchWriteItem` DynamoDB s'appliquent et **aucune expression de condition** ne peut être fournie.

Le document de mappage `BatchDeleteItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "BatchDeleteItem",
    "tables" : {
        "table1": [
        ## Item to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item2 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
        "table2": [
        ## Item3 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item4 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
    }
}
```

Les champs sont définis comme suit :

## BatchDeleteItem champs
<a name="BatchDeleteItem-list"></a>

### BatchDeleteItem liste des champs
<a name="BatchDeleteItem-list-col"></a>

** `version` **  
Version de la définition du modèle. Seule la clause `2018-05-29` est prise en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `BatchDeleteItem`, ce champ doit être défini sur `BatchDeleteItem`. Cette valeur est obligatoire.

** `tables` **  
Les tables DynamoDB dont les éléments doivent être supprimés. Chaque table est une liste de clés DynamoDB représentant la clé primaire des éléments à supprimer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Vous devez fournir au moins une table. La `tables` valeur est obligatoire.

Objets à mémoriser :
+ Contrairement à l'opération `DeleteItem`, l'élément complètement supprimé n'est pas renvoyé dans la réponse. Seule la clé passée est renvoyée.
+ Si un élément n'a pas été supprimé à partir de la table, un élément *null* s'affiche dans le bloc de données pour cette table.
+ Les résultats d'invocation sont triés par table, en fonction de l'ordre dans lequel ils ont été fournis dans le modèle de mappage des demandes.
+ Chaque `Delete` commande à l'intérieur de a `BatchDeleteItem` est atomique. Cependant, un lot peut être partiellement traité. Si un lot est traité partiellement en raison d'une erreur, les clés non traitées sont renvoyées dans le cadre du résultat de l'appel dans le bloc *unprocessedKeys*.
+  `BatchDeleteItem` est limité à 25 clés.
+ Cette opération **n'est pas** prise en charge lorsqu'elle est utilisée avec la détection de conflits. L'utilisation des deux en même temps peut entraîner une erreur.

Pour l'exemple de modèle de mappage de requête suivant :

```
{
  "version": "2018-05-29",
  "operation": "BatchDeleteItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          }
        }
    ],
  }
}
```

Le résultat de l'appel disponible dans `$ctx.result` est le suivant :

```
{
   "data": {
     "authors": [null],
     "posts": [
        # Was deleted
        {
          "author_id": "a1",
          "post_id": "p2"
        }
     ]
   },
   "unprocessedKeys": {
     "authors": [
        # This key was not processed due to an error
        {
          "author_id": "a1"
        }
      ],
     "posts": []
   }
}
```

`$ctx.error` contient des détails sur l'erreur. Les **données** clés, **unprocessedKeys** et la clé de chaque table fournie dans le modèle de mappage de requête sont assurés d'être présents dans le résultat de l'appel. Les éléments ayant été supprimés sont présents dans le bloc de **données**. Les éléments qui n'ont pas été traités sont marqués comme *null* dans le bloc de données et sont placés dans le bloc **unprocessedKeys**.

Pour un exemple plus complet, suivez le didacticiel DynamoDB Batch [avec ici AppSync Tutoriel : Résolveurs de lots DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).

# BatchPutItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item"></a>

Le document de mappage des demandes vous permet de `BatchPutItem` demander au résolveur AWS AppSync DynamoDB d'envoyer une `BatchWriteItem` demande à DynamoDB pour placer plusieurs éléments, éventuellement sur plusieurs tables. Pour ce modèle de requête, vous devez spécifier les valeurs suivantes :
+ Les noms de tables dans lesquels placer les éléments
+ Les éléments complets à placer dans chaque table

Les limites `BatchWriteItem` DynamoDB s'appliquent et **aucune expression de condition** ne peut être fournie.

Le document de mappage `BatchPutItem` a la structure suivante :

```
{
    "version" : "2018-05-29",
    "operation" : "BatchPutItem",
    "tables" : {
        "table1": [
        ## Item to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item2 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
        "table2": [
        ## Item3 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item4 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
    }
}
```

Les champs sont définis comme suit :

## BatchPutItem champs
<a name="BatchPutItem-list"></a>

### BatchPutItem liste des champs
<a name="BatchPutItem-list-col"></a>

** `version` **  
Version de la définition du modèle. Seule la clause `2018-05-29` est prise en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `BatchPutItem`, ce champ doit être défini sur `BatchPutItem`. Cette valeur est obligatoire.

** `tables` **  
Les tables DynamoDB dans lesquelles placer les éléments. Chaque entrée de table représente une liste d'éléments DynamoDB à insérer pour cette table spécifique. Vous devez fournir au moins une table. Cette valeur est obligatoire.

Objets à mémoriser :
+ Les éléments entièrement insérés sont renvoyés dans la réponse, en cas de succès.
+ Si un élément n'a pas été inséré dans la table, un élément *null* s'affiche dans le bloc de données pour cette table.
+ Les éléments insérés sont triés par table, en fonction de l'ordre dans lequel ils ont été fournis dans le modèle de mappage des demandes.
+ Chaque `Put` commande contenue dans a `BatchPutItem` est atomique, mais un lot peut être partiellement traité. Si un lot est traité partiellement en raison d'une erreur, les clés non traitées sont renvoyées dans le cadre du résultat de l'appel dans le bloc *unprocessedKeys*.
+  `BatchPutItem` est limité à 25 éléments.
+ Cette opération **n'est pas** prise en charge lorsqu'elle est utilisée avec la détection de conflits. L'utilisation des deux en même temps peut entraîner une erreur.

Pour l'exemple de modèle de mappage de requête suivant :

```
{
  "version": "2018-05-29",
  "operation": "BatchPutItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          },
          "author_name": {
            "S": "a1_name"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          },
          "post_title": {
            "S": "title"
          }
        }
    ],
  }
}
```

Le résultat de l'appel disponible dans `$ctx.result` est le suivant :

```
{
   "data": {
     "authors": [
         null
     ],
     "posts": [
        # Was inserted
        {
          "author_id": "a1",
          "post_id": "p2",
          "post_title": "title"
        }
     ]
   },
   "unprocessedItems": {
     "authors": [
        # This item was not processed due to an error
        {
          "author_id": "a1",
          "author_name": "a1_name"
        }
      ],
     "posts": []
   }
}
```

`$ctx.error` contient des détails sur l'erreur. Les **données** clés, **unprocessedItems** et la clé de chaque table fournie dans le modèle de mappage de requête sont assurés d'être présents dans le résultat de l'appel. Les éléments ayant été insérés sont dans le bloc de **données**. Les éléments qui n'ont pas été traités sont marqués comme *null* dans le bloc de données et sont placés dans le bloc **unprocessedItems**.

Pour un exemple plus complet, suivez le didacticiel DynamoDB Batch [avec ici AppSync Tutoriel : Résolveurs de lots DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch).

# TransactGetItems
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items"></a>

Le document de mappage des demandes vous permet de `TransactGetItems` demander au résolveur AWS AppSync DynamoDB d'envoyer une `TransactGetItems` demande à DynamoDB pour récupérer plusieurs éléments, éventuellement sur plusieurs tables. Pour ce modèle de requête, vous devez spécifier les valeurs suivantes :
+ Nom de la table de chaque élément de requête dans lequel extraire l'élément
+ La clé de chaque élément de requête à récupérer à partir de chaque table

Les limites `TransactGetItems` DynamoDB s'appliquent et **aucune expression de condition** ne peut être fournie.

Le document de mappage `TransactGetItems` a la structure suivante :

```
{
    "version": "2018-05-29",
    "operation": "TransactGetItems",
    "transactItems": [
       ## First request item
       {
           "table": "table1",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "projection" : {
                ...
           }
       },
       ## Second request item
       {
           "table": "table2",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "projection" : {
                ...
           }
       }
    ]
}
```

Les champs sont définis comme suit :

## TransactGetItems champs
<a name="TransactGetItems-list"></a>

### TransactGetItems liste des champs
<a name="TransactGetItems-list-col"></a>

** `version` **  
Version de la définition du modèle. Seule la clause `2018-05-29` est prise en charge. Cette valeur est obligatoire.

** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `TransactGetItems`, ce champ doit être défini sur `TransactGetItems`. Cette valeur est obligatoire.

** `transactItems` **  
Les éléments de requête à inclure. La valeur est un tableau d'éléments de requête. Au moins un élément de requête doit être fourni. Cette valeur `transactItems` est obligatoire.    
** `table` **  
La table DynamoDB à partir de laquelle récupérer l'élément. La valeur est une chaîne du nom de la table. Cette valeur `table` est obligatoire.  
** `key` **  
La clé DynamoDB représentant la clé primaire de l'élément à récupérer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)  
**`projection`**  
Projection utilisée pour spécifier les attributs à renvoyer par l'opération DynamoDB. Pour plus d'informations sur les projections, voir [Projections](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections). Ce champ est facultatif.

Objets à mémoriser :
+ Si une transaction réussit, l'ordre des éléments récupérés dans le bloc `items` sera le même que celui des éléments de la requête.
+ Les transactions sont effectuées d'une all-or-nothing manière ou d'une autre. Si un élément de requête provoque une erreur, la transaction entière ne sera pas effectuée et les détails de l'erreur seront retournés.
+ Un élément de requête qui ne peut pas être récupéré n'est pas une erreur. Au lieu de cela, un élément *null* apparaît dans le bloc *éléments* dans la position correspondante.
+ Si l'erreur d'une transaction est *TransactionCanceledException*survenue, le `cancellationReasons` bloc sera rempli. L'ordre des motifs d'annulation dans le bloc `cancellationReasons` sera le même que l'ordre des éléments de demande.
+  `TransactGetItems`est limité à 100 articles demandés.

Pour l'exemple de modèle de mappage de requête suivant :

```
{
    "version": "2018-05-29",
    "operation": "TransactGetItems",
    "transactItems": [
       ## First request item
       {
           "table": "posts",
           "key": {
               "post_id": {
                 "S": "p1"
               }
           }
       },
       ## Second request item
       {
           "table": "authors",
           "key": {
               "author_id": {
                 "S": a1
               }
           }
       }
    ]
}
```

Si la transaction réussit et que seul le premier élément demandé est extrait, le résultat d'appel disponible dans `$ctx.result` est le suivant :

```
{
    "items": [
       {
           // Attributes of the first requested item
           "post_id": "p1",
           "post_title": "title",
           "post_description": "description"
       },
       // Could not retrieve the second requested item
       null,
    ],
    "cancellationReasons": null
}
```

Si la transaction échoue en raison *TransactionCanceledException*du premier élément de demande, le résultat de l'invocation disponible `$ctx.result` est le suivant :

```
{
    "items": null,
    "cancellationReasons": [
       {
           "type":"Sample error type",
           "message":"Sample error message"
       },
       {
           "type":"None",
           "message":"None"
       }
    ]
}
```

`$ctx.error` contient des détails sur l'erreur. Les **éléments** clés et **cancellationReasons** sont nécessairement présents dans `$ctx.result`.

Pour un exemple plus complet, suivez le didacticiel sur les transactions DynamoDB AppSync avec ici Tutoriel [: résolveurs de transactions DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).

# TransactWriteItems
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transact-write-items"></a>

Le document de mappage des demandes vous permet de `TransactWriteItems` demander au résolveur AWS AppSync DynamoDB de `TransactWriteItems` demander à DynamoDB d'écrire plusieurs éléments, éventuellement dans plusieurs tables. Pour ce modèle de requête, vous devez spécifier les valeurs suivantes :
+ Nom de la table de destination de chaque élément de requête
+ L'opération de chaque élément de demande à effectuer. Quatre types d'opérations sont pris en charge : *PutItem*UpdateItem**, *DeleteItem*, et *ConditionCheck* 
+ La clé de chaque élément de demande à écrire

Les limites `TransactWriteItems` DynamoDB s'appliquent.

Le document de mappage `TransactWriteItems` a la structure suivante :

```
{
    "version": "2018-05-29",
    "operation": "TransactWriteItems",
    "transactItems": [
       {
           "table": "table1",
           "operation": "PutItem",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "attributeValues": {
               "baz": ... typed value
           },
           "condition": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table":"table2",
           "operation": "UpdateItem",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "update": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               }
           },
           "condition": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo":"foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table": "table3",
           "operation": "DeleteItem",
           "key":{
               "foo": ... typed value,
               "bar": ... typed value
           },
           "condition":{
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table": "table4",
           "operation": "ConditionCheck",
           "key":{
               "foo": ... typed value,
               "bar": ... typed value
           },
           "condition":{
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       }
    ]
}
```

## TransactWriteItems champs
<a name="TransactWriteItems-list"></a>

### TransactWriteItems liste des champs
<a name="TransactWriteItems-list-col"></a>

**Les champs sont définis comme suit :**    
** `version` **  
Version de la définition du modèle. Seule la clause `2018-05-29` est prise en charge. Cette valeur est obligatoire.  
** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `TransactWriteItems`, ce champ doit être défini sur `TransactWriteItems`. Cette valeur est obligatoire.  
** `transactItems` **  
Les éléments de requête à inclure. La valeur est un tableau d'éléments de requête. Au moins un élément de requête doit être fourni. Cette valeur `transactItems` est obligatoire.  
Pour `PutItem`, les champs sont définis comme suit :    
** `table` **  
La table DynamoDB de destination. La valeur est une chaîne du nom de la table. Cette valeur `table` est obligatoire.  
** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `PutItem`, ce champ doit être défini sur `PutItem`. Cette valeur est obligatoire.  
** `key` **  
La clé DynamoDB représentant la clé primaire de l'élément à insérer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.  
** `attributeValues` **  
Le reste des attributs de l'élément doit être placé dans DynamoDB. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Ce champ est facultatif.  
** `condition` **  
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `PutItem` remplace toute entrée existante pour cet élément. Vous pouvez spécifier s'il faut récupérer l'élément existant en cas d'échec de la vérification de l'état. Pour plus d'informations sur les conditions transactionnelles, consultez la section [Expressions des conditions de transaction](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Cette valeur est facultative.
Pour `UpdateItem`, les champs sont définis comme suit :    
** `table` **  
Table DynamoDB à mettre à jour. La valeur est une chaîne du nom de la table. Cette valeur `table` est obligatoire.  
** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `UpdateItem`, ce champ doit être défini sur `UpdateItem`. Cette valeur est obligatoire.  
** `key` **  
La clé DynamoDB représentant la clé primaire de l'élément à mettre à jour. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.  
** `update` **  
La `update` section vous permet de spécifier une expression de mise à jour qui décrit comment mettre à jour l'élément dans DynamoDB. Pour plus d'informations sur la façon d'écrire des expressions de mise à jour, consultez la documentation [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Cette section est obligatoire.  
** `condition` **  
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `UpdateItem` met à jour l'entrée existante quel que soit son état actuel. Vous pouvez spécifier s'il faut récupérer l'élément existant en cas d'échec de la vérification de l'état. Pour plus d'informations sur les conditions transactionnelles, consultez la section [Expressions des conditions de transaction](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Cette valeur est facultative.
Pour `DeleteItem`, les champs sont définis comme suit :    
** `table` **  
Table DynamoDB dans laquelle vous souhaitez supprimer l'élément. La valeur est une chaîne du nom de la table. Cette valeur `table` est obligatoire.  
** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `DeleteItem`, ce champ doit être défini sur `DeleteItem`. Cette valeur est obligatoire.  
** `key` **  
La clé DynamoDB représentant la clé primaire de l'élément à supprimer. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.  
** `condition` **  
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Si aucune condition n'est spécifiée, la requête `DeleteItem` supprime un élément existant quel que soit son état actuel. Vous pouvez spécifier s'il faut récupérer l'élément existant en cas d'échec de la vérification de l'état. Pour plus d'informations sur les conditions transactionnelles, consultez la section [Expressions des conditions de transaction](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Cette valeur est facultative.
Pour `ConditionCheck`, les champs sont définis comme suit :    
** `table` **  
Table DynamoDB dans laquelle vérifier la condition. La valeur est une chaîne du nom de la table. Cette valeur `table` est obligatoire.  
** `operation` **  
L'opération DynamoDB à effectuer. Pour que vous puissiez effectuer l'opération DynamoDB `ConditionCheck`, ce champ doit être défini sur `ConditionCheck`. Cette valeur est obligatoire.  
** `key` **  
La clé DynamoDB représentant la clé primaire de l'élément à vérifier. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou une clé de hachage et une clé de tri, selon la structure de la table. Pour plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Cette valeur est obligatoire.  
** `condition` **  
Condition permettant de déterminer si la demande doit réussir ou non, en fonction de l'état de l'objet déjà dans DynamoDB. Vous pouvez spécifier s'il faut récupérer l'élément existant en cas d'échec de la vérification de l'état. Pour plus d'informations sur les conditions transactionnelles, consultez la section [Expressions des conditions de transaction](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md). Cette valeur est obligatoire.

Objets à mémoriser :
+ Seules les clés des éléments de demande sont renvoyées dans la réponse, si elles réussissent. L'ordre des clés sera le même que l'ordre des éléments de demande.
+ Les transactions sont effectuées d'une all-or-nothing manière ou d'une autre. Si un élément de requête provoque une erreur, la transaction entière ne sera pas effectuée et les détails de l'erreur seront retournés.
+ Aucun élément de demande ne peut cibler le même élément. Sinon, ils provoqueront une *TransactionCanceledException*erreur.
+ Si l'erreur d'une transaction est *TransactionCanceledException*survenue, le `cancellationReasons` bloc sera rempli. Si la vérification de l'état d'un élément de demande échoue **et** que vous n'avez pas spécifié `returnValuesOnConditionCheckFailure` comme étant `false`, l'élément existant dans la table est récupéré et stocké `item` à la position correspondante du bloc `cancellationReasons`.
+  `TransactWriteItems`est limité à 100 articles demandés.
+ Cette opération **n'est pas** prise en charge lorsqu'elle est utilisée avec la détection de conflits. L'utilisation des deux en même temps peut entraîner une erreur.

Pour l'exemple de modèle de mappage de requête suivant :

```
{
    "version": "2018-05-29",
    "operation": "TransactWriteItems",
    "transactItems": [
       {
           "table": "posts",
           "operation": "PutItem",
           "key": {
               "post_id": {
                   "S": "p1"
               }
           },
           "attributeValues": {
               "post_title": {
                   "S": "New title"
               },
               "post_description": {
                   "S": "New description"
               }
           },
           "condition": {
               "expression": "post_title = :post_title",
               "expressionValues": {
                   ":post_title": {
                       "S": "Expected old title"
                   }
               }
           }
       },
       {
           "table":"authors",
           "operation": "UpdateItem",
           "key": {
               "author_id": {
                   "S": "a1"
               },
           },
           "update": {
               "expression": "SET author_name = :author_name",
               "expressionValues": {
                   ":author_name": {
                       "S": "New name"
                   }
               }
           },
       }
    ]
}
```

Si la transaction réussit, le résultat d'appel disponible dans `$ctx.result` est le suivant :

```
{
    "keys": [
       // Key of the PutItem request
       {
           "post_id": "p1",
       },
       // Key of the UpdateItem request
       {
           "author_id": "a1"
       }
    ],
    "cancellationReasons": null
}
```

Si la transaction échoue en raison de l'échec de la vérification de l'état de la `PutItem` demande, le résultat de l'invocation disponible `$ctx.result` est le suivant :

```
{
    "keys": null,
    "cancellationReasons": [
       {
           "item": {
               "post_id": "p1",
               "post_title": "Actual old title",
               "post_description": "Old description"
           },
           "type": "ConditionCheckFailed",
           "message": "The condition check failed."
       },
       {
           "type": "None",
           "message": "None"
       }
    ]
}
```

`$ctx.error` contient des détails sur l'erreur. Les clés **clés** et **cancellationReasons** sont nécessairement présentes dans `$ctx.result`.

Pour un exemple plus complet, suivez le didacticiel sur les transactions DynamoDB AppSync avec ici Tutoriel [: résolveurs de transactions DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).

# Système de types (mappage des demandes)
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request"></a>

Lorsque vous utilisez le résolveur AWS AppSync DynamoDB pour appeler vos tables DynamoDB AWS AppSync , vous devez connaître le type de chaque valeur à utiliser dans cet appel. Cela est dû au fait que DynamoDB prend en charge un plus grand nombre de primitives de type que GraphQL ou JSON (telles que les ensembles et les données binaires). AWS AppSync a besoin de quelques conseils lors de la traduction entre GraphQL et DynamoDB, sinon il devra émettre des hypothèses sur la manière dont les données sont structurées dans votre table.

[https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors)

Une valeur DynamoDB est représentée par un objet JSON contenant une seule paire clé-valeur. La clé indique le type DynamoDB et la valeur indique la valeur elle-même. Dans l'exemple suivant, la clé `S` indique que la valeur est une chaîne, et la valeur `identifier` est la valeur de chaîne elle-même.

```
{ "S" : "identifier" }
```

Notez que l'objet JSON ne peut pas avoir plus d'une paire clé-valeur. Si plusieurs paires clé-valeur sont spécifiées, le document de mappage des requêtes n'est pas analysé.

Une valeur DynamoDB est utilisée n'importe où dans un document de mappage de requêtes où vous devez spécifier une valeur. Vous devrez notamment procéder ainsi dans les sections suivantes : `key` et `attributeValue`, ainsi que la section `expressionValues` des sections d'expression. Dans l'exemple suivant, la `identifier` valeur DynamoDB String est affectée au `id` champ dans `key` une section (peut-être dans `GetItem` un document de mappage de demandes).

```
"key" : {
   "id" : { "S" : "identifier" }
}
```

 **Types pris en charge** 

AWS AppSync prend en charge les types de scalaire, de document et d'ensemble DynamoDB suivants :

**Type de chaîne `S` **  
Valeur de chaîne unique. Une valeur de chaîne DynamoDB est indiquée par :  

```
{ "S" : "some string" }
```
Voici un exemple d'utilisation :  

```
"key" : {
   "id" : { "S" : "some string" }
}
```

**Type d'ensemble de chaîne `SS` **  
Ensemble de valeurs de chaîne. La valeur d'un ensemble de chaînes DynamoDB est indiquée par :  

```
{ "SS" : [ "first value", "second value", ... ] }
```
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```

**Type de nombre `N` **  
Valeur numérique unique. La valeur d'un numéro DynamoDB est indiquée par :  

```
{ "N" : 1234 }
```
Voici un exemple d'utilisation :  

```
"expressionValues" : {
   ":expectedVersion" : { "N" : 1 }
}
```

**Type d'ensemble de nombres `NS` **  
Ensemble de valeurs de nombres. La valeur d'un ensemble de numéros DynamoDB est indiquée par :  

```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```

**Type binaire `B` **  
Valeur binaire. Une valeur binaire DynamoDB est désignée par :  

```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Notez que la valeur est en fait une chaîne, où la chaîne est la représentation codée en base64 des données binaires. AWS AppSync décode cette chaîne dans sa valeur binaire avant de l'envoyer à DynamoDB. AWS AppSync utilise le schéma de décodage base64 tel que défini par la RFC 2045 : tout caractère qui n'est pas dans l'alphabet base64 est ignoré.  
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```

**Type d'ensemble binaire `BS` **  
Ensemble de valeurs binaires. La valeur d'un ensemble binaire DynamoDB est désignée par :  

```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Notez que la valeur est en fait une chaîne, où la chaîne est la représentation codée en base64 des données binaires. AWS AppSync décode cette chaîne dans sa valeur binaire avant de l'envoyer à DynamoDB. AWS AppSync utilise le schéma de décodage base64 tel que défini par la RFC 2045 : tout caractère qui n'est pas dans l'alphabet base64 est ignoré.  
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```

**Type booléen `BOOL` **  
Valeur booléenne. Une valeur booléenne DynamoDB est désignée par :  

```
{ "BOOL" : true }
```
Notez que seules les valeurs `true` et `false` sont valides.  
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "orderComplete" : { "BOOL" : false }
}
```

**Type de liste `L` **  
Liste de toutes les autres valeurs DynamoDB prises en charge. Une valeur de liste DynamoDB est indiquée par :  

```
{ "L" : [ ... ] }
```
Notez que la valeur est une valeur composée, la liste pouvant contenir zéro ou plus de toute valeur DynamoDB prise en charge (y compris les autres listes). La liste peut également contenir une combinaison de différents types.  
Voici un exemple d'utilisation :  

```
{ "L" : [
      { "S"  : "A string value" },
      { "N"  : 1 },
      { "SS" : [ "Another string value", "Even more string values!" ] }
   ]
}
```

**Type de mappage `M` **  
Représentant une collection non ordonnée de paires clé-valeur d'autres valeurs DynamoDB prises en charge. La valeur d'une carte DynamoDB est indiquée par :  

```
{ "M" : { ... } }
```
Notez qu'un mappage peut contenir zéro ou plusieurs paires clé-valeur. La clé doit être une chaîne, et la valeur peut être n'importe quelle valeur DynamoDB prise en charge (y compris d'autres cartes). Le mappage peut également contenir une combinaison de différents types.  
Voici un exemple d'utilisation :  

```
{ "M" : {
      "someString" : { "S"  : "A string value" },
      "someNumber" : { "N"  : 1 },
      "stringSet"  : { "SS" : [ "Another string value", "Even more string values!" ] }
   }
}
```

**Type nul `NULL` **  
Valeur null. Une valeur DynamoDB Null est désignée par :  

```
{ "NULL" : null }
```
Voici un exemple d'utilisation :  

```
"attributeValues" : {
   "phoneNumbers" : { "NULL" : null }
}
```

Pour plus d'informations sur chaque type, consultez la [documentation DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).

# Système de types (mappage des réponses)
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses"></a>

Lorsque vous recevez une réponse de DynamoDB AWS AppSync , elle est automatiquement convertie en types primitifs GraphQL et JSON. Chaque attribut de DynamoDB est décodé et renvoyé dans le contexte de mappage des réponses.

Par exemple, si DynamoDB renvoie ce qui suit :

```
{
    "id" : { "S" : "1234" },
    "name" : { "S" : "Nadia" },
    "age" : { "N" : 25 }
}
```

Le résolveur AWS AppSync DynamoDB le convertit ensuite en types GraphQL et JSON sous la forme suivante :

```
{
    "id" : "1234",
    "name" : "Nadia",
    "age" : 25
}
```

Cette section explique comment AWS AppSync convertir les types de scalaire, de document et d'ensemble DynamoDB suivants :

**Type de chaîne `S` **  
Valeur de chaîne unique. Une valeur DynamoDB String est renvoyée sous forme de chaîne.  
Par exemple, si DynamoDB a renvoyé la valeur de chaîne DynamoDB suivante :  

```
{ "S" : "some string" }
```
AWS AppSync le convertit en chaîne :  

```
"some string"
```

**Type d'ensemble de chaîne `SS` **  
Ensemble de valeurs de chaîne. Une valeur d'ensemble de chaînes DynamoDB est renvoyée sous forme de liste de chaînes.  
Par exemple, si DynamoDB a renvoyé la valeur DynamoDB String Set suivante :  

```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync le convertit en une liste de chaînes :  

```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```

**Type de nombre `N` **  
Valeur numérique unique. La valeur d'un numéro DynamoDB est renvoyée sous forme de nombre.  
Par exemple, si DynamoDB a renvoyé la valeur du numéro DynamoDB suivante :  

```
{ "N" : 1234 }
```
AWS AppSync le convertit en nombre :  

```
1234
```

**Type d'ensemble de nombres `NS` **  
Ensemble de valeurs de nombres. Une valeur d'ensemble de numéros DynamoDB est renvoyée sous forme de liste de nombres.  
Par exemple, si DynamoDB a renvoyé la valeur DynamoDB Number Set suivante :  

```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync le convertit en une liste de nombres :  

```
[ 67.8, 12.2, 70 ]
```

**Type binaire `B` **  
Valeur binaire. Une valeur binaire DynamoDB est renvoyée sous forme de chaîne contenant la représentation base64 de cette valeur.  
Par exemple, si DynamoDB a renvoyé la valeur binaire DynamoDB suivante :  

```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync le convertit en une chaîne contenant la représentation base64 de la valeur :  

```
"SGVsbG8sIFdvcmxkIQo="
```
Notez que les données binaires sont codées selon le schéma Base64 tel que spécifié dans [RFC 4648](https://tools.ietf.org/html/rfc4648) et [RFC 2045](https://tools.ietf.org/html/rfc2045).

**Type d'ensemble binaire `BS` **  
Ensemble de valeurs binaires. Une valeur d'ensemble binaire DynamoDB est renvoyée sous la forme d'une liste de chaînes contenant la représentation base64 des valeurs.  
Par exemple, si DynamoDB a renvoyé la valeur d'ensemble binaire DynamoDB suivante :  

```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync le convertit en une liste de chaînes contenant la représentation en base64 des valeurs :  

```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
Notez que les données binaires sont codées selon le schéma Base64 tel que spécifié dans [RFC 4648](https://tools.ietf.org/html/rfc4648) et [RFC 2045](https://tools.ietf.org/html/rfc2045).

**Type booléen `BOOL` **  
Valeur booléenne. Une valeur booléenne DynamoDB est renvoyée sous forme de booléen.  
Par exemple, si DynamoDB a renvoyé la valeur booléenne DynamoDB suivante :  

```
{ "BOOL" : true }
```
AWS AppSync le convertit en booléen :  

```
true
```

**Type de liste `L` **  
Liste de toutes les autres valeurs DynamoDB prises en charge. Une valeur de liste DynamoDB est renvoyée sous forme de liste de valeurs, chaque valeur interne étant également convertie.  
Par exemple, si DynamoDB a renvoyé la valeur de liste DynamoDB suivante :  

```
{ "L" : [
      { "S"  : "A string value" },
      { "N"  : 1 },
      { "SS" : [ "Another string value", "Even more string values!" ] }
   ]
}
```
AWS AppSync le convertit en une liste de valeurs converties :  

```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```

**Type de mappage `M` **  
 key/value Collection de toute autre valeur DynamoDB prise en charge. Une valeur de carte DynamoDB est renvoyée sous forme d'objet JSON, où key/value chacune est également convertie.  
Par exemple, si DynamoDB a renvoyé la valeur de carte DynamoDB suivante :  

```
{ "M" : {
      "someString" : { "S"  : "A string value" },
      "someNumber" : { "N"  : 1 },
      "stringSet"  : { "SS" : [ "Another string value", "Even more string values!" ] }
   }
}
```
AWS AppSync le convertit en objet JSON :  

```
{
   "someString" : "A string value",
   "someNumber" : 1,
   "stringSet"  : [ "Another string value", "Even more string values!" ]
}
```

**Type nul `NULL` **  
Valeur null.  
Par exemple, si DynamoDB a renvoyé la valeur Null DynamoDB suivante :  

```
{ "NULL" : null }
```
AWS AppSync le convertit en valeur nulle :  

```
null
```

# Filtres
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-filter"></a>

Lorsque vous interrogez des objets dans DynamoDB à `Query` l'aide des opérations `Scan` et, vous pouvez éventuellement spécifier `filter` un qui évalue les résultats et renvoie uniquement les valeurs souhaitées.

La section de mappage de filtre d'un document de mappage `Query` ou `Scan` a la structure suivante :

```
"filter" : {
    "expression" : "filter expression"
    "expressionNames" : {
        "#name" : "name",
    },
    "expressionValues" : {
        ":value" : ... typed value
    },
}
```

Les champs sont définis comme suit :

** `expression` **  
Expression de la requête. Pour plus d'informations sur la façon d'écrire des expressions de filtre, consultez la documentation [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html) [et QueryFilter ScanFilter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html) DynamoDB. Ce champ doit être spécifié.

** `expressionNames` **  
Substituts des espaces réservés de *nom* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de nom utilisé dans le `expression`. La valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de nom des attributs de l'expression utilisés dans l'`expression`.

** `expressionValues` **  
Substituts des espaces réservés de *valeur* des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de valeur utilisé dans l'`expression`, et la valeur doit être typée. Pour de plus amples informations sur la spécification d'une « valeur typée », veuillez consulter [Système de types (mappage des requêtes)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Cela doit être spécifié. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de valeur des attributs de l'expression utilisés dans l'`expression`.

## Exemple
<a name="id18"></a>

L'exemple suivant est une section de filtre pour un modèle de mappage, dans laquelle les entrées extraites de DynamoDB ne sont renvoyées que si le titre commence par l'argument. `title`

```
"filter" : {
    "expression" : "begins_with(#title, :title)",
    "expressionNames" : {
        "#title" : "title"
    },
    "expressionValues" : {
        ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
    }
}
```

# Expressions conditionnelles
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions"></a>

Lorsque vous mutez des objets dans DynamoDB à l'aide des opérations`PutItem`,`UpdateItem`, et `DeleteItem` DynamoDB, vous pouvez éventuellement spécifier une expression de condition qui détermine si la demande doit aboutir ou non, en fonction de l'état de l'objet déjà présent dans DynamoDB avant l'exécution de l'opération.

Le résolveur AWS AppSync DynamoDB permet de spécifier une expression de condition `PutItem` dans `DeleteItem` et de demander des documents de mappage`UpdateItem`, ainsi qu'une stratégie à suivre si la condition échoue et que l'objet n'a pas été mis à jour.

## Exemple 1
<a name="id19"></a>

Le document de mappage `PutItem` suivant ne dispose pas d'une expression de condition. Par conséquent, il place un élément dans DynamoDB même s'il existe déjà un élément portant la même clé, remplaçant ainsi l'élément existant.

```
{
   "version" : "2017-02-28",
   "operation" : "PutItem",
   "key" : {
      "id" : { "S" : "1" }
   }
}
```

## Exemple 2
<a name="id20"></a>

Le document de `PutItem` mappage suivant contient une expression de condition qui permet à l'opération de réussir uniquement si un élément portant la même clé n'existe *pas* dans DynamoDB.

```
{
   "version" : "2017-02-28",
   "operation" : "PutItem",
   "key" : {
      "id" : { "S" : "1" }
   },
   "condition" : {
      "expression" : "attribute_not_exists(id)"
   }
}
```

Par défaut, si le contrôle de condition échoue, le résolveur AWS AppSync DynamoDB renvoie une erreur pour la mutation. Cependant, le résolveur AWS AppSync DynamoDB propose des fonctionnalités supplémentaires pour aider les développeurs à gérer certains cas extrêmes courants :
+ Si le résolveur AWS AppSync DynamoDB peut déterminer que la valeur actuelle dans DynamoDB correspond au résultat souhaité, il traite l'opération comme si elle avait réussi de toute façon.
+ Au lieu de renvoyer une erreur, vous pouvez configurer le résolveur pour appeler une fonction Lambda personnalisée afin de décider de la manière dont le résolveur AWS AppSync DynamoDB doit gérer la panne.

Cette opération est décrite plus en détail dans la section [Gestion d'un échec de contrôle de condition](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).

[Pour plus d'informations sur les expressions de conditions DynamoDB, consultez la documentation DynamoDB. ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)

## Spécifier une condition
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-specification"></a>

Les documents de mappage des demandes `PutItem`, `UpdateItem` et `DeleteItem` permettent tous la spécification d'une section de `condition` facultative. Si cette section est omise, aucune vérification de condition n'est effectuée. Si elle est spécifiée, la condition doit être true pour que l'opération réussisse.

Une section `condition` a la structure suivante :

```
"condition" : {
    "expression" : "someExpression"
    "expressionNames" : {
        "#foo" : "foo"
    },
    "expressionValues" : {
        ":bar" : ... typed value
    },
    "equalsIgnore" : [ "version" ],
    "consistentRead" : true,
    "conditionalCheckFailedHandler" : {
        "strategy" : "Custom",
        "lambdaArn" : "arn:..."
    }
}
```

Les champs suivants spécifient la condition :

** `expression` **  
Expression de mise à jour elle-même. Pour plus d'informations sur la façon d'écrire des expressions de condition, consultez la documentation [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Ce champ doit être spécifié.

** `expressionNames` **  
Substituts des espaces réservés de nom des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé utilisé dans l'*expression*, et la valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de nom des attributs de l'expression utilisés dans l'*expression*.

** `expressionValues` **  
Substituts des espaces réservés de valeur des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de valeur utilisé dans l'expression, et la valeur doit être typée. Pour de plus amples informations sur la spécification d'une « valeur typée », veuillez consulter [Système de types (mappage des requêtes)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Cela doit être spécifié. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de valeur des attributs de l'expression utilisés dans l'expression.

Les champs restants indiquent au résolveur AWS AppSync DynamoDB comment gérer un échec de vérification de condition :

** `equalsIgnore` **  
Lorsqu'une vérification de condition échoue lors de l'utilisation de l'`PutItem`opération, le résolveur AWS AppSync DynamoDB compare l'élément actuellement dans DynamoDB à l'élément qu'il a essayé d'écrire. S'ils sont identiques, il traite l'opération comme si elle avait réussi. Vous pouvez utiliser le `equalsIgnore` champ pour spécifier une liste d'attributs à AWS AppSync ignorer lors de cette comparaison. Par exemple, si la seule différence était un `version` attribut, il traite l'opération comme si elle avait réussi. Ce champ est facultatif.

** `consistentRead` **  
Lorsqu'une vérification de condition échoue, AWS AppSync obtient la valeur actuelle de l'élément auprès de DynamoDB à l'aide d'une lecture hautement cohérente. Vous pouvez utiliser ce champ pour indiquer au résolveur AWS AppSync DynamoDB d'utiliser une lecture éventuellement cohérente à la place. Ce champ est facultatif et contient `true` par défaut.

** `conditionalCheckFailedHandler` **  
Cette section vous permet de spécifier comment le résolveur AWS AppSync DynamoDB traite un échec de vérification de condition après avoir comparé la valeur actuelle dans DynamoDB au résultat attendu. Cette section est facultative. Si elle n'est pas spécifiée, la valeur par défaut est une stratégie `Reject`.    
** `strategy` **  
Stratégie adoptée par le résolveur AWS AppSync DynamoDB après avoir comparé la valeur actuelle dans DynamoDB au résultat attendu. Ce champ est obligatoire et les valeurs suivantes sont possibles :    
** `Reject` **  
La mutation échoue et une erreur est ajoutée à la réponse GraphQL.  
** `Custom` **  
Le résolveur AWS AppSync DynamoDB invoque une fonction Lambda personnalisée pour décider de la manière de gérer l'échec du contrôle de condition. Lorsque la `strategy` est définie sur `Custom`, le champ `lambdaArn` doit contenir l'ARN de la fonction Lambda à appeler.  
** `lambdaArn` **  
L'ARN de la fonction Lambda à invoquer qui détermine la manière dont le résolveur DynamoDB doit gérer l' AWS AppSync échec de la vérification des conditions. Ce champ doit être spécifié uniquement lorsque `strategy` est défini sur `Custom`. Pour plus d'informations sur l'utilisation de cette fonction, consultez [Gestion de l'échec d'une vérification de condition](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).

## Gestion d'un échec de vérification d'état
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling"></a>

Par défaut, lorsqu'une vérification de condition échoue, le résolveur AWS AppSync DynamoDB renvoie une erreur concernant la mutation et la valeur actuelle de l'objet dans DynamoDB. Cependant, le résolveur AWS AppSync DynamoDB propose des fonctionnalités supplémentaires pour aider les développeurs à gérer certains cas extrêmes courants :
+ Si le résolveur AWS AppSync DynamoDB peut déterminer que la valeur actuelle dans DynamoDB correspond au résultat souhaité, il traite l'opération comme si elle avait réussi de toute façon.
+ Au lieu de renvoyer une erreur, vous pouvez configurer le résolveur pour appeler une fonction Lambda personnalisée afin de décider de la manière dont le résolveur AWS AppSync DynamoDB doit gérer la panne.

Le diagramme de ce processus est le suivant :

![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/fr_fr/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)


### Vérification du résultat souhaité
<a name="checking-for-the-desired-result"></a>

Lorsque le contrôle de condition échoue, le résolveur AWS AppSync DynamoDB exécute `GetItem` une requête DynamoDB pour obtenir la valeur actuelle de l'élément auprès de DynamoDB. Par défaut, il utilise une lecture à cohérence forte, mais cela peut être configuré à l'aide du champ `consistentRead` dans le bloc `condition` et comparé aux résultats prévus :
+ Pour l'`PutItem`opération, le résolveur AWS AppSync DynamoDB compare la valeur actuelle à celle qu'il a tenté d'écrire, en excluant les attributs répertoriés dans `equalsIgnore` la comparaison. Si les éléments sont identiques, il considère l'opération comme réussie et renvoie l'élément extrait de DynamoDB. Dans le cas contraire, il suit la stratégie configurée.

  Par exemple, si le document de mappage des requêtes `PutItem` ressemble à ce qui suit :

  ```
  {
     "version" : "2017-02-28",
     "operation" : "PutItem",
     "key" : {
        "id" : { "S" : "1" }
     },
     "attributeValues" : {
        "name" : { "S" : "Steve" },
        "version" : { "N" : 2 }
     },
     "condition" : {
        "expression" : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : { "N" : 1 }
        },
        "equalsIgnore": [ "version" ]
     }
  }
  ```

  Et si l'élément actuellement dans DynamoDB ressemble à ce qui suit :

  ```
  {
     "id" : { "S" : "1" },
     "name" : { "S" : "Steve" },
     "version" : { "N" : 8 }
  }
  ```

  Le résolveur AWS AppSync DynamoDB comparait l'élément qu'il a essayé d'écrire à la valeur actuelle, constatant que la seule différence réside dans `version` le champ, mais comme il est configuré pour ignorer `version` le champ, il considère l'opération comme réussie et renvoie l'élément extrait de DynamoDB.
+ Pour l'`DeleteItem`opération, le résolveur AWS AppSync DynamoDB vérifie qu'un élément a été renvoyé par DynamoDB. Si aucun élément n'a été renvoyé, il traite l'opération comme réussie. Dans le cas contraire, il suit la stratégie configurée.
+ Pour l'`UpdateItem`opération, le résolveur AWS AppSync DynamoDB ne dispose pas de suffisamment d'informations pour déterminer si l'élément actuellement dans DynamoDB correspond au résultat attendu et suit donc la stratégie configurée.

Si l'état actuel de l'objet dans DynamoDB est différent du résultat attendu, le résolveur AWS AppSync DynamoDB suit la stratégie configurée, soit pour rejeter la mutation, soit pour invoquer une fonction Lambda pour déterminer la marche à suivre.

### Suivre la stratégie du « rejet »
<a name="following-the-reject-strategy"></a>

Lorsque vous suivez la `Reject` stratégie, le résolveur AWS AppSync DynamoDB renvoie une erreur pour la mutation.

Par exemple, si nous avons la demande de mutation suivante :

```
mutation {
    updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
        Name
        theVersion
    }
}
```

Si l'élément renvoyé par DynamoDB ressemble à ce qui suit :

```
{
   "id" : { "S" : "1" },
   "name" : { "S" : "Steve" },
   "version" : { "N" : 8 }
}
```

Et si le modèle de mappage des réponses ressemble à ce qui suit :

```
{
   "id" : $util.toJson($context.result.id),
   "Name" : $util.toJson($context.result.name),
   "theVersion" : $util.toJson($context.result.version)
}
```

La réponse GraphQL se présente comme suit :

```
{
  "data": null,
  "errors": [
    {
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      ...
    }
  ]
}
```

Notez également que si des champs de l'objet renvoyé sont remplis par d'autres résolveurs et que la mutation a réussi, ils ne seront pas résolus lorsque l'objet sera renvoyé dans la section `error`.

### Suivre la stratégie « personnalisée »
<a name="following-the-custom-strategy"></a>

Lorsqu'il suit la `Custom` stratégie, le résolveur AWS AppSync DynamoDB invoque une fonction Lambda pour décider de la marche à suivre. La fonction Lambda choisit l'une des options suivantes :
+  `reject` la mutation. Cela indique au résolveur AWS AppSync DynamoDB de se comporter comme si la stratégie configurée l'`Reject`était, renvoyant une erreur pour la mutation et la valeur actuelle de l'objet dans DynamoDB, comme décrit dans la section précédente.
+  `discard` la mutation. Cela indique au résolveur AWS AppSync DynamoDB d'ignorer silencieusement l'échec de la vérification des conditions et renvoie la valeur dans DynamoDB.
+  `retry` la mutation. Cela indique au résolveur AWS AppSync DynamoDB de réessayer la mutation avec un nouveau document de mappage de requêtes.

 **Requête d'appel Lambda** 

Le résolveur AWS AppSync DynamoDB invoque la fonction Lambda spécifiée dans le. `lambdaArn` Il utilise le même `service-role-arn` que celui configuré sur la source de données. La charge utile de l'appel a la structure suivante :

```
{
    "arguments": { ... },
    "requestMapping": {... },
    "currentValue": { ... },
    "resolver": { ... },
    "identity": { ... }
}
```

Les champs sont définis comme suit :

** `arguments` **  
Arguments de la mutation GraphQL. Ce sont les mêmes arguments que ceux disponibles pour le document de mappage des demandes dans `$context.arguments`.

** `requestMapping` **  
Document de mappage des demandes pour cette opération.

** `currentValue` **  
Valeur actuelle de l'objet dans DynamoDB.

** `resolver` **  
Informations sur le AWS AppSync résolveur.

** `identity` **  
Informations sur l'appelant. Ce sont les mêmes informations que celles disponibles pour le document de mappage des demandes dans `$context.identity`.

Exemple complet de la charge utile :

```
{
    "arguments": {
        "id": "1",
        "name": "Steve",
        "expectedVersion": 1
    },
    "requestMapping": {
        "version" : "2017-02-28",
        "operation" : "PutItem",
        "key" : {
           "id" : { "S" : "1" }
        },
        "attributeValues" : {
           "name" : { "S" : "Steve" },
           "version" : { "N" : 2 }
        },
        "condition" : {
           "expression" : "version = :expectedVersion",
           "expressionValues" : {
               ":expectedVersion" : { "N" : 1 }
           },
           "equalsIgnore": [ "version" ]
        }
    },
    "currentValue": {
        "id" : { "S" : "1" },
        "name" : { "S" : "Steve" },
        "version" : { "N" : 8 }
    },
    "resolver": {
        "tableName": "People",
        "awsRegion": "us-west-2",
        "parentType": "Mutation",
        "field": "updatePerson",
        "outputType": "Person"
    },
    "identity": {
        "accountId": "123456789012",
        "sourceIp": "x.x.x.x",
        "user": "AIDAAAAAAAAAAAAAAAAAA",
        "userArn": "arn:aws:iam::123456789012:user/appsync"
    }
}
```

 **Réponse à l'appel de Lambda** 

La fonction Lambda peut inspecter la charge utile d'appel et appliquer n'importe quelle logique métier pour décider de la manière dont le résolveur DynamoDB doit gérer AWS AppSync la panne. Il existe trois options pour gérer l'échec de vérification de la condition :
+  `reject` la mutation. La charge utile de la réponse pour cette option doit avoir cette structure :

  ```
  {
      "action": "reject"
  }
  ```

  Cela indique au résolveur AWS AppSync DynamoDB de se comporter comme si la stratégie configurée l'`Reject`était, renvoyant une erreur pour la mutation et la valeur actuelle de l'objet dans DynamoDB, comme décrit dans la section ci-dessus.
+  `discard` la mutation. La charge utile de la réponse pour cette option doit avoir cette structure :

  ```
  {
      "action": "discard"
  }
  ```

  Cela indique au résolveur AWS AppSync DynamoDB d'ignorer silencieusement l'échec de la vérification des conditions et renvoie la valeur dans DynamoDB.
+  `retry` la mutation. La charge utile de la réponse pour cette option doit avoir cette structure :

  ```
  {
      "action": "retry",
      "retryMapping": { ... }
  }
  ```

  Cela indique au résolveur AWS AppSync DynamoDB de réessayer la mutation avec un nouveau document de mappage de requêtes. La structure de `retryMapping` cette section dépend de l'opération DynamoDB et constitue un sous-ensemble du document complet de mappage des demandes pour cette opération.

  Pour `PutItem`, la section `retryMapping` a la structure suivante. Pour une description du `attributeValues` champ, voir [PutItem](aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.md).

  ```
  {
      "attributeValues": { ... },
      "condition": {
          "equalsIgnore" = [ ... ],
          "consistentRead" = true
      }
  }
  ```

  Pour `UpdateItem`, la section `retryMapping` a la structure suivante. Pour une description de `update` cette section, voir [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md).

  ```
  {
      "update" : {
          "expression" : "someExpression"
          "expressionNames" : {
              "#foo" : "foo"
          },
          "expressionValues" : {
              ":bar" : ... typed value
          }
      },
      "condition": {
          "consistentRead" = true
      }
  }
  ```

  Pour `DeleteItem`, la section `retryMapping` a la structure suivante.

  ```
  {
      "condition": {
          "consistentRead" = true
      }
  }
  ```

  Il n'y a aucun moyen de spécifier une autre opération ou une autre clé sur laquelle travailler. Le résolveur AWS AppSync DynamoDB autorise uniquement les tentatives de la même opération sur le même objet. D'autre part, la section `condition` ne permet pas de spécifier un `conditionalCheckFailedHandler`. Si la nouvelle tentative échoue, le résolveur AWS AppSync DynamoDB suit la stratégie. `Reject`

Voici un exemple de fonction Lambda pour traiter une demande `PutItem` qui a échoué. La logique métier s'adresse à celui qui effectue l'appel. S'il a été créé par`jeffTheAdmin`, il réessaie la demande en mettant à jour le `version` et à `expectedVersion` partir de l'élément actuellement présent dans DynamoDB. Dans le cas contraire, il rejette la mutation.

```
exports.handler = (event, context, callback) => {
    console.log("Event: "+ JSON.stringify(event));

    // Business logic goes here.

    var response;
    if ( event.identity.user == "jeffTheAdmin" ) {
        response = {
            "action" : "retry",
            "retryMapping" : {
                "attributeValues" : event.requestMapping.attributeValues,
                "condition" : {
                    "expression" : event.requestMapping.condition.expression,
                    "expressionValues" : event.requestMapping.condition.expressionValues
                }
            }
        }
        response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
        response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version

    } else {
        response = { "action" : "reject" }
    }

    console.log("Response: "+ JSON.stringify(response))
    callback(null, response)
};
```

# Expressions des conditions de transaction
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions"></a>

Les expressions de condition de transaction sont disponibles dans les modèles de mappage de requêtes des quatre types d'opérations dans `TransactWriteItems`, à savoir `PutItem`, `DeleteItem`, `UpdateItem` et `ConditionCheck`.

Pour`PutItem`, et `DeleteItem``UpdateItem`, l'expression de condition de transaction est facultative. En effet`ConditionCheck`, l'expression de la condition de transaction est obligatoire.

## Exemple 1
<a name="id22"></a>

Le document de mappage transactionnel `DeleteItem` suivant n'a pas d'expression de condition. Par conséquent, il supprime l'élément dans DynamoDB.

```
{
   "version": "2018-05-29",
   "operation": "TransactWriteItems",
   "transactItems": [
      {
         "table": "posts",
         "operation": "DeleteItem",
         "key": {
            "id": { "S" : "1" }
         }
      }
   ]
}
```

## Exemple 2
<a name="id23"></a>

Le document de `DeleteItem` mappage transactionnel suivant contient une expression de condition de transaction qui permet à l'opération de réussir uniquement si l'auteur de cette publication porte un certain nom.

```
{
   "version": "2018-05-29",
   "operation": "TransactWriteItems",
   "transactItems": [
      {
         "table": "posts",
         "operation": "DeleteItem",
         "key": {
            "id": { "S" : "1" }
         }
         "condition": {
            "expression": "author = :author",
            "expressionValues": {
               ":author": { "S" : "Chunyan" }
            }
         }
      }
   ]
}
```

Si la vérification de condition échoue, elle provoque `TransactionCanceledException` et les détails de l'erreur sont renvoyés dans `$ctx.result.cancellationReasons`. Notez que par défaut, l'ancien élément de DynamoDB à l'origine de l'échec de la vérification des conditions sera renvoyé. `$ctx.result.cancellationReasons`

## Spécifier une condition
<a name="id24"></a>

Les documents de mappage des demandes `PutItem`, `UpdateItem` et `DeleteItem` permettent tous la spécification d'une section de `condition` facultative. Si cette section est omise, aucune vérification de condition n'est effectuée. Si elle est spécifiée, la condition doit être true pour que l'opération réussisse. Le `ConditionCheck` doit avoir une section `condition` à spécifier. La condition doit être vraie pour que l'ensemble de la transaction réussisse.

Une section `condition` a la structure suivante :

```
"condition": {
    "expression": "someExpression",
    "expressionNames": {
        "#foo": "foo"
    },
    "expressionValues": {
        ":bar": ... typed value
    },
    "returnValuesOnConditionCheckFailure": false
}
```

Les champs suivants spécifient la condition :

** `expression` **  
Expression de mise à jour elle-même. Pour plus d'informations sur la façon d'écrire des expressions de condition, consultez la documentation [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Ce champ doit être spécifié.

** `expressionNames` **  
Substituts des espaces réservés de nom des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé utilisé dans l'*expression*, et la valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de nom des attributs de l'expression utilisés dans l'*expression*.

** `expressionValues` **  
Substituts des espaces réservés de valeur des attributs de l'expression, sous la forme de paires clé-valeur. La clé correspond à un espace réservé de valeur utilisé dans l'expression, et la valeur doit être typée. Pour de plus amples informations sur la spécification d'une « valeur typée », veuillez consulter Système de types (mappage des requêtes). Cela doit être spécifié. Ce champ est facultatif et doit être renseigné uniquement avec des substituts des espaces réservés de valeur des attributs de l'expression utilisés dans l'expression.

** `returnValuesOnConditionCheckFailure` **  
Spécifiez s'il faut récupérer l'élément dans DynamoDB en cas d'échec d'une vérification de condition. L'élément récupéré est dans `$ctx.result.cancellationReasons[$index].item`, où `$index` est l'index de l'élément de demande qui a échoué à la vérification de condition. Cette valeur est définie par défaut sur true.

# Projections
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-projections"></a>

Lorsque vous lisez des objets dans DynamoDB à `GetItem` l'aide des opérations `Scan``Query`,`BatchGetItem`,, `TransactGetItems` et, vous pouvez éventuellement spécifier une projection qui identifie les attributs souhaités. La structure de la projection est la suivante, similaire à celle des filtres : 

```
"projection" : {
    "expression" : "projection expression"
    "expressionNames" : {
        "#name" : "name",
    }
}
```

Les champs sont définis comme suit :

**`expression`**   
L'expression de projection, qui est une chaîne. Pour récupérer un seul attribut, spécifiez son nom. Pour les attributs multiples, les noms doivent être des valeurs séparées par des virgules. Pour plus d'informations sur l'écriture d'expressions de projection, consultez la documentation sur les expressions de projection [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Ce champ est obligatoire. 

 **`expressionNames`**   
Les substitutions aux espaces réservés aux *noms* d'attributs d'expression sous forme de paires clé-valeur. La clé correspond à un espace réservé de nom utilisé dans le `expression`. La valeur doit être une chaîne correspondant au nom d'attribut de l'élément dans DynamoDB. Ce champ est facultatif et ne doit être rempli qu'avec des substitutions pour les espaces réservés aux noms d'attributs d'expression utilisés dans le. `expression` Pour plus d'informations`expressionNames`, consultez la documentation [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html). 

## Exemple 1
<a name="id25"></a>

L'exemple suivant est une section de projection pour un modèle de mappage VTL dans lequel seuls les attributs `author` et B `id` sont renvoyés par DynamoDB :

```
"projection" : {
    "expression" : "#author, id",
    "expressionNames" : {
        "#author" : "author"
    }
}
```

**Astuce**  
[Vous pouvez accéder à votre ensemble de sélection de requêtes GraphQL à l'aide de \$1context.info. selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html#aws-appsync-resolver-context-reference-info). Ce champ vous permet de cadrer votre expression de projection de manière dynamique en fonction de vos besoins.

**Note**  
Lorsque vous utilisez des expressions de projection avec les `Scan` opérations `Query` et, la valeur de `select` doit être`SPECIFIC_ATTRIBUTES`. Pour plus d'informations, consultez la documentation [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).

# AWS AppSync référence du modèle de mappage du résolveur pour RDS
<a name="resolver-mapping-template-reference-rds"></a>

Les modèles de mappage du résolveur AWS AppSync RDS permettent aux développeurs d'envoyer des requêtes SQL à une API de données pour Amazon Aurora Serverless et de récupérer le résultat de ces requêtes.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

Le modèle de mappage de demande RDS est relativement simple :

```
{
    "version": "2018-05-29",
    "statements": [],
    "variableMap": {},
    "variableTypeHintMap": {}
}
```

Voici la représentation du schéma JSON du modèle de mappage de demande RDS, une fois qu'il est résolu :

```
{
    "definitions": {},
    "$schema": "https://json-schema.org/draft-07/schema#",
    "$id": "https://example.com/root.json",
    "type": "object",
    "title": "The Root Schema",
    "required": [
        "version",
        "statements",
        "variableMap"
    ],
    "properties": {
        "version": {
            "$id": "#/properties/version",
            "type": "string",
            "title": "The Version Schema",
            "default": "",
            "examples": [
                "2018-05-29"
            ],
            "enum": [
                "2018-05-29"
            ],
            "pattern": "^(.*)$"
        },
        "statements": {
            "$id": "#/properties/statements",
            "type": "array",
            "title": "The Statements Schema",
            "items": {
                "$id": "#/properties/statements/items",
                "type": "string",
                "title": "The Items Schema",
                "default": "",
                "examples": [
                    "SELECT * from BOOKS"
                ],
                "pattern": "^(.*)$"
            }
        },
        "variableMap": {
            "$id": "#/properties/variableMap",
            "type": "object",
            "title": "The Variablemap Schema"
        },
        "variableTypeHintMap": {
            "$id": "#/properties/variableTypeHintMap",
            "type": "object",
            "title": "The variableTypeHintMap Schema"
        }
    }
}
```

Voici un exemple de modèle de mappage de demandes avec une requête statique :

```
{
    "version": "2018-05-29",
    "statements": [
        "select title, isbn13 from BOOKS where author = 'Mark Twain'"
    ]
}
```

## Version
<a name="version"></a>

Commun à tous les modèles de mappage de demandes, le champ de version définit la version utilisée par le modèle. Le champ de version est obligatoire. La valeur « 2018-05-29 » est la seule version prise en charge pour les modèles de mappage Amazon RDS.

```
"version": "2018-05-29"
```

## Déclarations et VariableMap
<a name="statements-variablemap"></a>

Le tableau des instructions est un espace réservé pour les requêtes fournies par le développeur. Actuellement, jusqu'à deux requêtes par modèle de mappage de demandes sont prises en charge. `variableMap`Il s'agit d'un champ facultatif qui contient des alias qui peuvent être utilisés pour raccourcir les instructions SQL et les rendre plus lisibles. Par exemple, les solutions suivantes sont possibles :

```
{
"version": "2018-05-29",
    "statements": [
        "insert into BOOKS VALUES (:AUTHOR, :TITLE, :ISBN13)",
        "select * from BOOKS WHERE isbn13 = :ISBN13"
    ],
    "variableMap": {
        ":AUTHOR": $util.toJson($ctx.args.newBook.author),
        ":TITLE": $util.toJson($ctx.args.newBook.title),
        ":ISBN13": $util.toJson($ctx.args.newBook.isbn13)
    }
}
```

AWS AppSync utilisera les valeurs cartographiques variables pour créer les **[SqlParameterized](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html)**requêtes qui seront envoyées à l'API de données sans serveur Amazon Aurora. Les instructions SQL sont exécutées avec les paramètres fournis dans la carte des variables, ce qui élimine le risque d'injection de code SQL. 

## VariableTypeHintMap
<a name="variabletypehintmap"></a>

`variableTypeHintMap`Il s'agit d'un champ facultatif contenant des types aliasés qui peuvent être utilisés pour envoyer des indications sur le type de [paramètre SQL](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html). Ces indications de type évitent le transtypage explicite des instructions SQL, ce qui les raccourcit. Par exemple, les solutions suivantes sont possibles :

```
{
    "version": "2018-05-29",
    "statements": [
        "insert into LOGINDATA VALUES (:ID, :TIME)",
        "select * from LOGINDATA WHERE id = :ID"
     ],
     "variableMap": {
        ":ID": $util.toJson($ctx.args.id),
        ":TIME": $util.toJson($ctx.args.time)
     },
     "variableTypeHintMap": {
        ":id": "UUID",
        ":time": "TIME"
     }
}
```

AWS AppSync utilisera la valeur cartographique variable pour créer les requêtes envoyées à l'API de données sans serveur Amazon Aurora. Il utilise également les `variableTypeHintMap` données et envoie les informations du type à RDS. [Le support RDS `typeHints` peut être trouvé ici.](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html)

# AWS AppSync référence du modèle de mappage du résolveur pour OpenSearch
<a name="resolver-mapping-template-reference-elasticsearch"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Le AWS AppSync résolveur pour Amazon OpenSearch Service vous permet d'utiliser GraphQL pour stocker et récupérer des données dans les domaines de service OpenSearch existants de votre compte. Ce résolveur fonctionne en vous permettant de mapper une requête GraphQL entrante en OpenSearch une demande de service, puis de mapper la réponse OpenSearch du service à GraphQL. Cette section décrit les modèles de mappage pour les opérations de OpenSearch service prises en charge.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

La plupart des modèles de mappage des demandes de OpenSearch service ont une structure commune dans laquelle seuls quelques éléments changent. L'exemple suivant exécute une recherche dans un domaine OpenSearch de service, où les documents sont organisés sous un index appelé`post`. Les paramètres de recherche sont définis dans la section `body`, avec un grand nombre de clauses de requête courants définies dans le champ `query`. Cet exemple recherche des documents contenant `"Nadia"` ou `"Bailey"`, ou les deux, dans le champ `author` d'un document :

```
{
    "version":"2017-02-28",
    "operation":"GET",
    "path":"/post/_search",
    "params":{
        "headers":{},
        "queryString":{},
        "body":{
            "from":0,
            "size":50,
            "query" : {
                "bool" : {
                    "should" : [
                        {"match" : { "author" : "Nadia" }},
                        {"match" : { "author" : "Bailey" }}
                    ]
                }
            }
        }
    }
}
```

## Modèle de mappage des réponses
<a name="response-mapping-template"></a>

Comme pour les autres sources de données, OpenSearch Service envoie une réponse AWS AppSync qui doit être convertie en GraphQL.

La plupart des requêtes GraphQL recherchent le `_source` champ à partir d'une réponse de OpenSearch service. Comme vous pouvez effectuer des recherches pour renvoyer un document individuel ou une liste de documents, deux modèles de mappage des réponses sont couramment utilisés dans OpenSearch Service :

 **Liste des résultats** 

```
[
    #foreach($entry in $context.result.hits.hits)
      #if( $velocityCount > 1 ) , #end
        $utils.toJson($entry.get("_source"))
    #end
]
```

 **Élément individuel** 

```
$utils.toJson($context.result.get("_source"))
```

## `operation` field
<a name="operation-field"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Méthode ou verbe HTTP (GET, POST, PUT, HEAD ou DELETE) qui AWS AppSync envoie vers le domaine OpenSearch de service. La clé et la valeur doivent être une chaîne.

```
"operation" : "PUT"
```

## `path` field
<a name="path-field"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Le chemin de recherche d'une demande OpenSearch de service auprès de AWS AppSync. Cela forme une URL pour le verbe HTTP de l'opération. La clé et la valeur doivent être des chaînes.

```
"path" : "/<indexname>/_doc/<_id>"
"path" : "/<indexname>/_doc"
"path" : "/<indexname>/_search"
"path" : "/<indexname>/_update/<_id>
```

Lorsque le modèle de mappage est évalué, ce chemin est envoyé dans le cadre de la requête HTTP, y compris le domaine OpenSearch de service. Ainsi, l'exemple précédent pourrait donner :

```
GET https://opensearch-domain-name.REGION.es.amazonaws.com/indexname/type/_search
```

## `params` field
<a name="params-field"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Permet de spécifier l'action exécutée par votre recherche, plus couramment en définissant la valeur de **requête** à l'intérieur du **corps**. Toutefois, il existe plusieurs autres capacités qui peuvent être configurées, comme la mise en forme des réponses.
+  **headers** 

  Informations d'en-tête, sous forme de paires clé-valeur. La clé et la valeur doivent être des chaînes. Par exemple :

  ```
  "headers" : {
      "Content-Type" : "application/json"
  }
  ```
**Note**  
AWS AppSync ne prend actuellement en charge que le format JSON en tant que fichier`Content-Type`.
+  **queryString** 

  Paires clé-valeur qui spécifient les options courantes, telles que la mise en forme du code pour les réponses JSON. La clé et la valeur doivent être une chaîne. Par exemple, si vous souhaitez obtenir un JSON mis en forme correctement, vous devez utiliser :

  ```
  "queryString" : {
      "pretty" : "true"
  }
  ```
+  **body** 

  Il s'agit de la partie principale de votre demande, qui permet AWS AppSync de créer une demande de recherche bien formée pour votre domaine OpenSearch de service. La clé doit être une chaîne composée d'un objet. Voici quelques démonstrations.

 **Exemple 1** 

Renvoyer tous les documents avec une ville correspondant à « seattle » :

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "match" : {
            "city" : "seattle"
        }
    }
}
```

 **Exemple 2** 

Renvoyer tous les documents correspondant à « washington » comme ville ou État :

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "multi_match" : {
            "query" : "washington",
            "fields" : ["city", "state"]
        }
    }
}
```

## Transmission de variables
<a name="passing-variables"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Vous pouvez également transmettre des variables dans le cadre d'une évaluation dans l'instruction VTL. Par exemple, supposons que vous ayez une requête GraphQL similaire à la suivante :

```
query {
    searchForState(state: "washington"){
        ...
    }
}
```

Le modèle de mappage pourrait avoir l'état comme argument :

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "multi_match" : {
            "query" : "$context.arguments.state",
            "fields" : ["city", "state"]
        }
    }
}
```

Pour obtenir la liste des utilitaires que vous pouvez inclure dans la VTL, consultez [En-têtes de requête d'accès](resolver-context-reference.md#aws-appsync-resolver-context-reference-util).

# AWS AppSync référence du modèle de mappage du résolveur pour Lambda
<a name="resolver-mapping-template-reference-lambda"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

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 utiliser des modèles de mappage pour donner des indications AWS AppSync sur la nature de l'opération à invoquer. Cette section décrit les différents modèles de mappage pour les opérations Lambda prises en charge.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

Le modèle de mappage de requêtes Lambda gère les champs liés à votre fonction Lambda :

```
{
  "version": string,
  "operation": Invoke|BatchInvoke,
  "payload": any type,
  "invocationType": RequestResponse|Event
}
```

Voici la représentation du schéma JSON du modèle de mappage de demandes Lambda une fois résolu :

```
{
  "definitions": {},
  "$schema": "https://json-schema.org/draft-06/schema#",
  "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
  "type": "object",
  "properties": {
    "version": {
      "$id": "/properties/version",
      "type": "string",
      "enum": [
        "2018-05-29"
      ],
      "title": "The Mapping template version.",
      "default": "2018-05-29"
    },
    "operation": {
      "$id": "/properties/operation",
      "type": "string",
      "enum": [
        "Invoke",
        "BatchInvoke"
      ],
      "title": "The Mapping template operation.",
      "description": "What operation to execute.",
      "default": "Invoke"
    },
    "payload": {},
    "invocationType": {
      "$id": "/properties/invocationType",
      "type": "string",
      "enum": [
        "RequestResponse",
        "Event"
      ],
      "title": "The Mapping template invocation type.",
      "description": "What invocation type to execute.",
      "default": "RequestResponse"
    }
  },
  "required": [
    "version",
    "operation"
  ],
  "additionalProperties": false
}
```

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 :

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": $util.toJson($context.arguments)
  }
}
```

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 :

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": {
      "id": "postId1"
    }
  }
}
```

### Version
<a name="version"></a>

Commun à tous les modèles de mappage de demandes, il `version` définit la version utilisée par le modèle. Le `version` est obligatoire et est une valeur statique :

```
"version": "2018-05-29"
```

### Opération
<a name="operation"></a>

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`, le modèle de mappage des demandes résolues correspond à la charge utile d'entrée de la fonction Lambda. Modifions l'exemple ci-dessus :

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": $util.toJson($context.arguments)
    }
}
```

Ceci est résolu et transmis à la fonction Lambda, qui pourrait ressembler à ceci :

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": {
        "id": "postId1"
      }
    }
}
```

En `BatchInvoke` effet, le modèle de mappage est appliqué à chaque résolveur de champs du lot. Par souci de concision, AWS AppSync fusionne toutes les `payload` valeurs du modèle de mappage résolues dans une liste sous un seul objet correspondant au modèle de mappage. Le modèle d'exemple suivant affiche la fusion :

```
{
  "version": "2018-05-29",
  "operation": "BatchInvoke",
  "payload": $util.toJson($context)
}
```

Ce modèle est résolu dans le document de mappage suivant :

```
{
  "version": "2018-05-29",
  "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
<a name="payload"></a>

Le `payload` champ est un conteneur utilisé pour transmettre n'importe quel JSON bien formé à 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
<a name="async-invocation-type"></a>

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 :

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "invocationType": "Event"
  "payload": {
    "arguments": $util.toJson($context.arguments)
  }
}
```

Ceci est résolu et transmis à la fonction Lambda, qui pourrait ressembler à ceci :

```
{
  "version": "2018-05-29",
  "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` 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.

## Modèle de mappage des réponses
<a name="response-mapping-template"></a>

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 défini sur l'`context`objet disponible via la propriété Velocity Template Language (VTL). `$context.result`

Si la forme de la réponse de la fonction Lambda correspond exactement à celle du type GraphQL, vous pouvez transmettre la réponse à l'aide du modèle de mappage de réponse suivant :

```
$util.toJson($context.result)
```

Il n'y a pas de champs obligatoires ni de restrictions des formes qui s'appliquent au modèle de mappage de la réponse. Toutefois, dans la mesure où GraphQL est fortement typé, le modèle de mappage résolu doit correspondre au type GraphQL prévu.

## Réponse par lots de la fonction Lambda
<a name="aws-appsync-resolver-mapping-template-reference-lambda-batched-response"></a>

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.

## Résolveurs Lambda directs
<a name="direct-lambda-resolvers"></a>

Si vous souhaitez éviter complètement l'utilisation de modèles de mappage, vous AWS AppSync pouvez fournir une charge utile par défaut à votre fonction Lambda et une réponse de fonction Lambda par défaut à un type GraphQL. Vous pouvez choisir de fournir un modèle de demande, un modèle de réponse ou aucun des deux, et AWS AppSync le gérer en conséquence.

### Modèle de mappage de requêtes Lambda direct
<a name="lambda-mapping-template-bypass-request"></a>

Lorsque le modèle de mappage de demandes n'est pas fourni, l'`Context`objet AWS AppSync sera envoyé directement à votre fonction Lambda sous forme d'`Invoke`opération. Pour plus d'informations sur la structure de l'objet `Context`, consultez [AWS AppSync référence contextuelle du modèle de mappage du résolveur](resolver-context-reference.md).

### Modèle de mappage des réponses Lambda directes
<a name="lambda-mapping-template-bypass-response"></a>

Lorsque le modèle de mappage des réponses n'est pas fourni, AWS AppSync effectuez l'une des deux opérations suivantes après avoir reçu la réponse de votre fonction Lambda. Si vous n'avez pas fourni de modèle de mappage de demandes ou si vous avez fourni un modèle de mappage de demandes avec la version`2018-05-29`, la réponse sera équivalente au modèle de mappage de réponse suivant :

```
#if($ctx.error)
     $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
 #end
 $util.toJson($ctx.result)
```

Si vous avez fourni un modèle avec la version`2017-02-28`, la logique de réponse fonctionne de la même manière que le modèle de mappage des réponses suivant :

```
$util.toJson($ctx.result)
```

À première vue, le contournement du modèle de mappage fonctionne de la même manière que l'utilisation de certains modèles de mappage, comme indiqué dans les exemples précédents. Cependant, dans les coulisses, l'évaluation des modèles de mappage est totalement contournée. Dans la mesure où l'étape d'évaluation du modèle est contournée, les applications peuvent être confrontées à moins de surcharge et de latence pendant la réponse dans certains scénarios par rapport à une fonction Lambda avec un modèle de mappage des réponses qui doit être évalué. 

### Gestion personnalisée des erreurs dans les réponses Direct Lambda Resolver
<a name="lambda-mapping-template-bypass-errors"></a>

Vous pouvez personnaliser les réponses aux erreurs issues des fonctions Lambda invoquées par les résolveurs Lambda directs en déclenchant une exception personnalisée. L'exemple suivant montre comment créer une exception personnalisée à l'aide de JavaScript :

```
class CustomException extends Error {
  constructor(message) {
    super(message);
    this.name = "CustomException";
  }
}
 
throw new CustomException("Custom message");
```

Lorsque des exceptions sont déclenchées, les `errorType` `name` et `errorMessage` `message` sont respectivement les et et de l'erreur personnalisée générée.

Si `errorType` tel est le cas`UnauthorizedException`, AWS AppSync renvoie le message par défaut (`"You are not authorized to make this call."`) au lieu d'un message personnalisé.

L'extrait suivant est un exemple de réponse GraphQL illustrant une personnalisation : `errorType`

```
{
  "data": {
    "query": null
  },
  "errors": [
    {
      "path": [
        "query"
      ],
      "data": null,
      "errorType": "CustomException",
      "errorInfo": null,
      "locations": [
        {
          "line": 5,
          "column": 10,
          "sourceName": null
        }
      ],
      "message": "Custom Message"
    }
  ]
}
```

### Résolveurs Lambda directs : le traitement par lots est activé
<a name="lambda-resolvers-batching"></a>

Vous pouvez activer le traitement par lots pour votre résolveur Lambda direct en le `maxBatchSize` configurant sur votre résolveur. Lorsqu'il `maxBatchSize` est défini sur une valeur supérieure à celle `0` d'un résolveur Lambda direct, il AWS AppSync envoie des requêtes par lots à votre fonction Lambda dans des tailles allant jusqu'à. `maxBatchSize` 

Le réglage `maxBatchSize` `0` sur sur un résolveur Direct Lambda désactive le traitement par lots.

Pour plus d'informations sur le fonctionnement du traitement par lots avec des résolveurs Lambda, consultez. [Cas d'utilisation avancé : traitement par lots](tutorial-lambda-resolvers.md#advanced-use-case-batching)

#### Modèle de mappage des demandes
<a name="lambda-resolvers-batching-request-template"></a>

Lorsque le traitement par lots est activé et que le modèle de mappage des demandes n'est pas fourni, AWS AppSync envoie une liste d'`Context`objets sous forme d'`BatchInvoke`opération directement à votre fonction Lambda.

#### Modèle de mappage des réponses
<a name="lambda-resolvers-batching-response-template"></a>

Lorsque le traitement par lots est activé et que le modèle de mappage des réponses n'est pas fourni, la logique de réponse est équivalente au modèle de mappage des réponses suivant :

```
#if( $context.result && $context.result.errorMessage )
      $utils.error($context.result.errorMessage, $context.result.errorType,
      $context.result.data)
#else
      $utils.toJson($context.result.data)
#end
```

La fonction Lambda doit renvoyer une liste de résultats dans le même ordre que la liste des `Context` objets envoyés. Vous pouvez renvoyer des erreurs individuelles en fournissant un `errorMessage` et `errorType` pour un résultat spécifique. Chaque résultat de la liste a le format suivant :

```
{
   "data" : { ... }, // your data
   "errorMessage" : { ... }, // optional, if included an error entry is added to the "errors" object in the AppSync response 
   "errorType" : { ... } // optional, the error type
}
```

**Note**  
Les autres champs de l'objet de résultat sont actuellement ignorés.

#### Gestion des erreurs liées à Lambda
<a name="lambda-resolvers-batching-error-handling"></a>

Vous pouvez renvoyer une erreur pour tous les résultats en lançant une exception ou une erreur dans votre fonction Lambda. Si la taille de la demande de charge utile ou de réponse pour votre demande de lot est trop importante, Lambda renvoie une erreur. Dans ce cas, vous devez envisager de réduire votre charge utile de réponse `maxBatchSize` ou de réduire sa taille.

Pour plus d'informations sur la gestion des erreurs individuelles, voir[Renvoi d'erreurs individuelles](tutorial-lambda-resolvers.md#returning-individual-errors).

#### Exemples de fonctions Lambda
<a name="sample-lambda-function"></a>

À l'aide du schéma ci-dessous, vous pouvez créer un résolveur Lambda direct pour le résolveur de `Post.relatedPosts` champs et activer le traitement par lots en définissant les paramètres ci-dessus : `maxBatchSize` `0`

```
schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id:ID!): Post
    allPosts: [Post]
}

type Mutation {
    addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!
}

type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    relatedPosts: [Post]
}
```

Dans la requête suivante, la fonction Lambda sera appelée avec des lots de demandes à résoudre : `relatedPosts`

```
query getAllPosts {
  allPosts {
    id
    relatedPosts {
      id
    }
  }
}
```

Une implémentation simple d'une fonction Lambda est fournie ci-dessous :

```
const posts = {
  1: {
    id: '1',
    title: 'First book',
    author: 'Author1',
    url: 'https://amazon.com/',
    content:
      'SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1',
    ups: '100',
    downs: '10',
  },
  2: {
    id: '2',
    title: 'Second book',
    author: 'Author2',
    url: 'https://amazon.com',
    content: 'SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT',
    ups: '100',
    downs: '10',
  },
  3: { id: '3', title: 'Third book', author: 'Author3', url: null, content: null, ups: null, downs: null },
  4: {
    id: '4',
    title: 'Fourth book',
    author: 'Author4',
    url: 'https://www.amazon.com/',
    content:
      'SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4',
    ups: '1000',
    downs: '0',
  },
  5: {
    id: '5',
    title: 'Fifth book',
    author: 'Author5',
    url: 'https://www.amazon.com/',
    content: 'SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT',
    ups: '50',
    downs: '0',
  },
}

const relatedPosts = {
  1: [posts['4']],
  2: [posts['3'], posts['5']],
  3: [posts['2'], posts['1']],
  4: [posts['2'], posts['1']],
  5: [],
}
exports.handler = async (event) => {
  console.log('event ->', event)
  // retrieve the ID of each post
  const ids = event.map((context) => context.source.id)
  // fetch the related posts for each post id
  const related = ids.map((id) => relatedPosts[id])

  // return the related posts; or an error if none were found
  return related.map((r) => {
    if (r.length > 0) {
      return { data: r }
    } else {
      return { data: null, errorMessage: 'Not found', errorType: 'ERROR' }
    }
  })
}
```

# AWS AppSync référence du modèle de mappage du résolveur pour EventBridge
<a name="resolver-mapping-template-reference-eventbridge"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Le modèle de mappage du AWS AppSync résolveur utilisé avec la source de EventBridge données vous permet d'envoyer des événements personnalisés au EventBridge bus Amazon.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

Le modèle de mappage des `PutEvents` demandes vous permet d'envoyer plusieurs événements personnalisés à un bus d' EventBridgeévénements. Le document de mappage a la structure suivante :

```
{
    "version" : "2018-05-29", 
    "operation" : "PutEvents",
    "events" : [{}]
}
```

Voici un exemple de modèle de mappage de demandes pour EventBridge : 

```
{
    "version": "2018-05-29",
    "operation": "PutEvents",
    "events": [{
        "source": "com.mycompany.myapp",
        "detail": {
            "key1" : "value1",
            "key2" : "value2"
        },
        "detailType": "myDetailType1"
    },
    {
        "source": "com.mycompany.myapp",
        "detail": {
            "key3" : "value3",
            "key4" : "value4"
        },
        "detailType": "myDetailType2",
        "resources" : ["Resource1", "Resource2"],
        "time" : "2023-01-01T00:30:00.000Z"
    }
    
    ]
}
```

## Modèle de mappage des réponses
<a name="response-mapping-template"></a>

Si l'`PutEvents`opération est réussie, la réponse du formulaire EventBridge est incluse dans le `$ctx.result` :

```
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
#end
  $util.toJson($ctx.result)
```

Les erreurs qui se produisent lors de l'exécution d'`PutEvents`opérations telles que `InternalExceptions` ou `Timeouts` apparaîtront dans`$ctx.error`. Pour obtenir la liste EventBridge des erreurs courantes, consultez la [référence des erreurs EventBridge courantes](https://docs.aws.amazon.com/eventbridge/latest/APIReference/CommonErrors.html).

Ce `result` sera dans le format suivant :

```
{
    "Entries" [
        {
            "ErrorCode" : String,
            "ErrorMessage" : String,
            "EventId" : String
        }
    ],
    "FailedEntryCount" : number
}
```
+ **Entrées**

  L'événement ingéré entraîne à la fois un succès et un échec. Si l'ingestion a réussi, l'entrée `EventID` en contient. Sinon, vous pouvez utiliser le `ErrorCode` et `ErrorMessage` pour identifier le problème lié à l'entrée.

  Pour chaque enregistrement, l'index de l'élément de réponse est le même que celui du tableau de requêtes.
+ **FailedEntryCount**

  Le nombre d'entrées ayant échoué. Cette valeur est représentée sous la forme d'un entier.

Pour plus d'informations sur la réponse de`PutEvents`, voir [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_ResponseElements).

**Exemple de réponse 1**

L'exemple suivant est une `PutEvents` opération avec deux événements réussis :

```
{
    "Entries" : [ 
        {
            "EventId": "11710aed-b79e-4468-a20b-bb3c0c3b4860"
        }, 
        {
            "EventId": "d804d26a-88db-4b66-9eaf-9a11c708ae82"
        }
    ],
    "FailedEntryCount" : 0
}
```

**Exemple de réponse 2**

L'exemple suivant est une `PutEvents` opération comportant trois événements, deux réussites et un échec :

```
{
    "Entries" : [ 
        {
            "EventId": "11710aed-b79e-4468-a20b-bb3c0c3b4860"
        }, 
        {
            "EventId": "d804d26a-88db-4b66-9eaf-9a11c708ae82"
        },
        {
            "ErrorCode" : "SampleErrorCode",
            "ErrorMessage" : "Sample Error Message"
        }
    ],
    "FailedEntryCount" : 1
}
```

## Champs de `PutEvents`
<a name="putevents-field"></a>

`PutEvents`contient les champs du modèle de mappage suivants :
+ **Version**

  Commun à tous les modèles de mappage de demandes, le `version` champ définit la version utilisée par le modèle. Ce champ est obligatoire. La valeur `2018-05-29` est la seule version prise en charge pour les modèles de EventBridge mappage.
+ **Opération**

  La seule opération prise en charge est`PutEvents`. Cette opération vous permet d'ajouter des événements personnalisés à votre bus d'événements.
+ **Événements**

  Un ensemble d'événements qui seront ajoutés au bus d'événements. Ce tableau doit avoir une allocation de 1 à 10 éléments.

  L'`Event`objet est un objet JSON valide qui comporte les champs suivants :
  + `"source"`: chaîne qui définit la source de l'événement.
  + `"detail"`: objet JSON que vous pouvez utiliser pour joindre des informations sur l'événement. Ce champ peut être une carte vide (`{ }`).
  + `"detailType`: chaîne identifiant le type d'événement.
  + `"resources"`: tableau JSON de chaînes identifiant les ressources impliquées dans l'événement. Ce champ peut être un tableau vide.
  + `"time"`: l'horodatage de l'événement fourni sous forme de chaîne. Cela doit suivre le format d'[RFC3339](https://www.rfc-editor.org/rfc/rfc3339.txt)horodatage.

Les extraits ci-dessous sont des exemples d'objets valides `Event` :

**Exemple 1**

```
{
    "source" : "source1",
    "detail" : {
        "key1" : [1,2,3,4],
        "key2" : "strval"
    },
    "detailType" : "sampleDetailType",
    "resources" : ["Resouce1", "Resource2"],
    "time" : "2022-01-10T05:00:10Z"
}
```

**Exemple 2**

```
{
    "source" : "source1",
    "detail" : {},
    "detailType" : "sampleDetailType"
}
```

**Exemple 3**

```
{
    "source" : "source1",
    "detail" : {
        "key1" : 1200
    },
    "detailType" : "sampleDetailType",
    "resources" : []
}
```

# AWS AppSync référence du modèle de mappage du résolveur pour la source de `None` données
<a name="resolver-mapping-template-reference-none"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Le modèle de mappage du AWS AppSync résolveur utilisé avec la source de données de type *None* vous permet de façonner les demandes pour les opérations AWS AppSync locales.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

Le modèle de mappage est simple et vous permet de transmettre autant d'informations contextuelles que possible via le champ `payload`.

```
{
   "version": string,
   "payload": any type
}
```

Voici la représentation du schéma JSON du modèle de mappage de demande, une fois qu'il est résolu :

```
{
    "definitions": {},
    "$schema": "https://json-schema.org/draft-06/schema#",
    "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
    "type": "object",
    "properties": {
        "version": {
            "$id": "/properties/version",
            "type": "string",
            "enum": [
                "2018-05-29"
            ],
            "title": "The Mapping template version.",
            "default": "2018-05-29"
        },
        "payload": {}
    },
    "required": [
        "version"
    ],
    "additionalProperties": false
}
```

Voici un exemple où les arguments du champ sont transmis via la propriété `$context.arguments` de contexte VTL :

```
{
    "version": "2018-05-29",
    "payload": $util.toJson($context.arguments)
}
```

La valeur du champ `payload` est transmise au modèle de mappage de réponse et est alors disponible dans la propriété de contexte VTL (`$context.result`).

Voici un exemple représentant la valeur interpolée du champ `payload` :

```
{
    "id": "postId1"
}
```

## Version
<a name="version"></a>

Commun à tous les modèles de mappage de demandes, le `version` champ définit la version utilisée par le modèle.

 Le champ `version` est obligatoire.

Exemple :

```
"version": "2018-05-29"
```

## Charge utile
<a name="payload"></a>

Le champ `payload` est un conteneur qui peut être utilisé pour transmettre tout élément JSON de format correct au modèle de mappage de réponse.

 Le champ `payload` est facultatif.

## Modèle de mappage des réponses
<a name="response-mapping-template"></a>

Étant donné qu'il n'y a pas de source de données, la valeur du champ `payload` est transmise au modèle de mappage de réponse et définie sur l'objet `context` qui est disponible via la propriété VTL `$context.result`.

Si la forme de la valeur du champ `payload` correspond exactement à celle du type GraphQL, vous pouvez transmettre la réponse à l'aide du modèle de mappage de réponse suivant :

```
$util.toJson($context.result)
```

Il n'y a pas de champs obligatoires ni de restrictions des formes qui s'appliquent au modèle de mappage de la réponse. Toutefois, dans la mesure où GraphQL est fortement typé, le modèle de mappage résolu doit correspondre au type GraphQL prévu.

# AWS AppSync référence du modèle de mappage du résolveur pour HTTP
<a name="resolver-mapping-template-reference-http"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Les modèles de mappage du résolveur AWS AppSync HTTP vous permettent d'envoyer des demandes depuis AWS AppSync n'importe quel point de terminaison HTTP, et des réponses de votre point de terminaison HTTP vers AWS AppSync. À l'aide de modèles de mappage, vous pouvez fournir des indications AWS AppSync sur la nature de l'opération à invoquer. Cette section décrit les différents modèles de mappage pour le résolveur HTTP pris en charge.

## Modèle de mappage des demandes
<a name="request-mapping-template"></a>

```
{
    "version": "2018-05-29",
    "method": "PUT|POST|GET|DELETE|PATCH",
    "params": {
        "query": Map,
        "headers": Map,
        "body": any
    },
    "resourcePath": string
}
```

Une fois le modèle de mappage de demande HTTP résolu, la représentation du schéma JSON du modèle de mappage de demande ressemble à ce qui suit :

```
{
    "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
    "type": "object",
    "properties": {
        "version": {
        "$id": "/properties/version",
        "type": "string",
        "title": "The Version Schema ",
        "default": "",
        "examples": [
            "2018-05-29"
        ],
        "enum": [
            "2018-05-29"
        ]
        },
        "method": {
        "$id": "/properties/method",
        "type": "string",
        "title": "The Method Schema ",
        "default": "",
        "examples": [
            "PUT|POST|GET|DELETE|PATCH"
        ],
        "enum": [
            "PUT",
            "PATCH",
            "POST",
            "DELETE",
            "GET"
        ]
        },
        "params": {
        "$id": "/properties/params",
        "type": "object",
        "properties": {
            "query": {
            "$id": "/properties/params/properties/query",
            "type": "object"
            },
            "headers": {
            "$id": "/properties/params/properties/headers",
            "type": "object"
            },
            "body": {
            "$id": "/properties/params/properties/body",
            "type": "string",
            "title": "The Body Schema ",
            "default": "",
            "examples": [
                ""
            ]
            }
        }
        },
        "resourcePath": {
        "$id": "/properties/resourcePath",
        "type": "string",
        "title": "The Resourcepath Schema ",
        "default": "",
        "examples": [
            ""
        ]
        }
    },
    "required": [
        "version",
        "method",
        "resourcePath"
    ]
}
```

Voici un exemple de demande HTTP POST, avec un corps `text/plain` :

```
{
    "version": "2018-05-29",
    "method": "POST",
    "params": {
        "headers":{
        "Content-Type":"text/plain"
        },
        "body":"this is an example of text body"
    },
    "resourcePath": "/"
}
```

## Version
<a name="version"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Définit la version utilisée par le modèle. `version` est commun à tous les modèles de mappage de demande et obligatoire.

```
"version": "2018-05-29"
```

## Method
<a name="method"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Méthode ou verbe HTTP (GET, POST, PUT, PATCH ou DELETE) qui AWS AppSync envoie au point de terminaison HTTP.

```
"method": "PUT"
```

## ResourcePath
<a name="resourcepath"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Chemin de la ressource à laquelle vous souhaitez accéder. Avec le point de terminaison dans la source de données HTTP, le chemin de la ressource constitue l'URL à laquelle le AWS AppSync service envoie une demande.

```
"resourcePath": "/v1/users"
```

Lorsque le modèle de mappage est évalué, ce chemin est envoyé dans le cadre de la demande HTTP, y compris le point de terminaison HTTP. Ainsi, l'exemple précédent pourrait donner :

```
PUT <endpoint>/v1/users
```

## Champs de paramètres
<a name="params-field"></a>

**Note**  
Cela s'applique uniquement au modèle de mappage des demandes. 

Permet de spécifier l'action exécutée par votre recherche, plus couramment en définissant la valeur de **query** à l'intérieur de la section **body**. Toutefois, il existe plusieurs autres capacités qui peuvent être configurées, comme la mise en forme des réponses.

** **headers** **  
Informations d'en-tête, sous forme de paires clé-valeur. La clé et la valeur doivent être des chaînes.  
Par exemple :  

```
"headers" : {
    "Content-Type" : "application/json"
}
```
Les en-têtes `Content-Type` actuellement pris en charge sont les suivants :  

```
text/*
application/xml
application/json
application/soap+xml
application/x-amz-json-1.0
application/x-amz-json-1.1
application/vnd.api+json
application/x-ndjson
```
 **Remarque :** vous ne pouvez pas définir les en-têtes HTTP suivants :  

```
HOST
CONNECTION
USER-AGENT
EXPECTATION
TRANSFER_ENCODING
CONTENT_LENGTH
```

** **query** **  
Paires clé-valeur qui spécifient les options courantes, telles que la mise en forme du code pour les réponses JSON. La clé et la valeur doivent être une chaîne. L'exemple suivant montre comment envoyer une chaîne de requête comme `?type=json` :  

```
"query" : {
    "type" : "json"
}
```

** **body** **  
Le corps contient le corps de la demande HTTP que vous choisissez de définir. Le corps de la demande est toujours une chaîne encodée en UTF-8, sauf si le type de contenu spécifie le jeu de caractères.  

```
"body":"body string"
```

## Réponse
<a name="response"></a>

Consultez un exemple [ici](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-http-resolvers.html).

# Autorités de certification (CA) reconnues par AWS AppSync les points de terminaison HTTPS
<a name="http-cert-authorities"></a>

**Note**  
Let's Encrypt est accepté via les certificats *idtrust* et *isrgrootx1*. Aucune action de votre part n'est requise si vous utilisez Let's Encrypt.

À l'heure actuelle, les certificats auto-signés ne sont pas pris en charge par les résolveurs HTTP lors de l'utilisation du protocole HTTPS. AWS AppSync reconnaît les autorités de certification suivantes lors de la résolution des certificats SSL/TLS pour HTTPS :


**Certificats racines connus dans AWS AppSync**  

| Nom | Date | SHA1 Empreinte | 
| --- | --- | --- | 
| digicertassuredidrootca | 21 avril 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| trustcenterclass2caii | 21 avril 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| thawtepremiumserverca | 21 avril 2018 | E0:AB:05:94:20:72:54:93:05:60:62:02:36:70:F7:CD:2E:FC:66:66 | 
| cia-crt-g3-02-ca | 23 novembre 2016 | 96:4A:BB:A7:BD:DA:FC:97:34:C0:0A:2D:F0:05:98:F7:E6:C6:6F:09 | 
| swisssignplatinumg2ca | 21 avril 2018 | 56:E0:FA:C0:3B:8F:18:23:55:18:E5:D3:11:CA:E8:C2:43:31:AB:66 | 
| swisssignsilverg2ca | 21 avril 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| thawteserverca | 21 avril 2018 | 9F:AD:91:A6:CE:6A:C6:C5:00:47:C4:4E:C9:D4:A5:0D:92:D8:49:79 | 
| equifaxsecureebusinessca1 | 21 avril 2018 | AE:E6:3D:70:E3:76:FB:C7:3A:EB:B0:A1:C1:D4:C4:7A:A7:40:B3:F4 | 
| securetrustca | 21 avril 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| utnuserfirstclientauthemailca | 21 avril 2018 | B1:72:B1:A5:6D:95:F9:1F:E5:02:87:E1:4D:37:EA:6A:44:63:76:8A | 
| thawtepersonalfreemailca | 21 avril 2018 | E6:18:83:AE:84:CA:C1:C1:CD:52:AD:E8:E9:25:2B:45:A6:4F:B7:E2 | 
| affirmtrustnetworkingca | 21 avril 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| entrustevca | 21 avril 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| utnuserfirsthardwareca | 21 avril 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| certumca | 21 avril 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| addtrustclass1ca | 21 avril 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| entrustrootcag2 | 21 avril 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| equifaxsecureca | 21 avril 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| quovadisrootca3 | 21 avril 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 21 avril 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| digicertglobalrootg2 | 21 avril 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| digicerthighassuranceevrootca | 21 avril 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| secomvalicertclass1ca | 21 avril 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| equifaxsecureglobalebusinessca1 | 21 avril 2018 | 3A:74:CB:7A:47:DB:70:DE:89:1F:24:35:98:64:B8:2D:82:BD:1A:36 | 
| geotrustuniversalca | 21 avril 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| deprecateditsecca | 27 janvier 2012 | 12:12:0B:03:0E:15:14:54:F4:DD:B3:F5:DE:13:6E:83:5A:29:72:9D | 
| verisignclass3ca | 21 avril 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| thawteprimaryrootcag3 | 21 avril 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| thawteprimaryrootcag2 | 21 avril 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| deutschetelekomrootca2 | 21 avril 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| buypassclass3ca | 21 avril 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| utnuserfirstobjectca | 21 avril 2018 | E1:2D:FB:4B:41:D7:D9:C3:2B:30:51:4B:AC:1D:81:D8:38:5E:2D:46 | 
| geotrustprimaryca | 21 avril 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| buypassclass2ca | 21 avril 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| baltimorecodesigningca | 21 avril 2018 | 30:46:D8:C8:88:FF:69:30:C3:4A:FC:CD:49:27:08:7C:60:56:7B:0D | 
| verisignclass1ca | 21 avril 2018 | CE:6A:64:A3:09:E4:2F:BB:D9:85:1C:45:3E:64:09:EA:E8:7D:60:F1 | 
| baltimorecybertrustca | 21 avril 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| starfieldclass2ca | 21 avril 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| camerfirmachamberscommerceca | 21 avril 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| ttelesecglobalrootclass3ca | 21 avril 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| verisignclass3g5ca | 21 avril 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| ttelesecglobalrootclass2ca | 21 avril 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| trustcenteruniversalcai | 21 avril 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| verisignclass3g4ca | 21 avril 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3g3ca | 21 avril 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| xrampglobalca | 21 avril 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| amzninternalrootca | 12 déc. 2008 | A7:B7:F6:15:8A:FF:1E:C8:85:13:38:BC:93:EB:A2:AB:A4:09:EF:06 | 
| certplusclass3pprimaryca | 21 avril 2018 | 21:6B:2A:29:E6:2A:00:CE:82:01:46:D8:24:41:41:B9:25:11:B2:79 | 
| certumtrustednetworkca | 21 avril 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| verisignclass3g2ca | 21 avril 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| globalsignr3ca | 21 avril 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| utndatacorpsgcca | 21 avril 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| secomscrootca2 | 21 avril 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| gtecybertrustglobalca | 21 avril 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| secomscrootca1 | 21 avril 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| affirmtrustcommercialca | 21 avril 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| trustcenterclass4caii | 21 avril 2018 | A6:9A:91:FD:05:7F:13:6A:42:63:0B:B1:76:0D:2D:51:12:0C:16:50 | 
| verisignuniversalrootca | 21 avril 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| globalsignr2ca | 21 avril 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| certplusclass2primaryca | 21 avril 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| digicertglobalrootca | 21 avril 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| globalsignca | 21 avril 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| thawteprimaryrootca | 21 avril 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| starfieldrootg2ca | 21 avril 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| geotrustglobalca | 21 avril 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| soneraclass2ca | 21 avril 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| verisigntsaca | 21 avril 2018 | 20:CE:B1:F0:F5:1C:0E:19:A9:F3:8D:B1:AA:8E:03:8C:AA:7A:C7:01 | 
| soneraclass1ca | 21 avril 2018 | 07:47:22:01:99:CE:74:B9:7C:B0:3D:79:B2:64:A2:C8:55:E9:33:FF | 
| quovadisrootca | 21 avril 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| affirmtrustpremiumeccca | 21 avril 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| starfieldservicesrootg2ca | 21 avril 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| valicertclass2ca | 21 avril 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| comodoaaaca | 21 avril 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| aolrootca2 | 21 avril 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| keynectisrootca | 21 avril 2018 | 9C:61:5C:4D:4D:85:10:3A:53:26:C2:4D:BA:EA:E4:A2:D2:D5:CC:97 | 
| addtrustqualifiedca | 21 avril 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| aolrootca1 | 21 avril 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| verisignclass2g3ca | 21 avril 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| addtrustexternalca | 21 avril 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| verisignclass2g2ca | 21 avril 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| geotrustprimarycag3 | 21 avril 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycag2 | 21 avril 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| swisssigngoldg2ca | 21 avril 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| entrust2048ca | 21 avril 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| chunghwaepkirootca | 21 avril 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| camerfirmachambersignca | 21 avril 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| camerfirmachambersca | 21 avril 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| godaddyclass2ca | 21 avril 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| affirmtrustpremiumca | 21 avril 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| verisignclass1g3ca | 21 avril 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| secomevrootca1 | 21 avril 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| verisignclass1g2ca | 21 avril 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| amzninternalinfoseccag3 | 27 février 2015 | B9:B1:CA:38:F7:BF:9C:D2:D4:95:E7:B6:5E:75:32:9B:A8:78:2E:F6 | 
| cia-crt-g3-01-ca | 23 novembre 2016 | 2B:EE:2C:BA:A3:1D:B5:FE:60:40:41:95:08:ED:46:82:39:4D:ED:E2 | 
| godaddyrootg2ca | 21 avril 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| digicertassuredidrootca | 21 avril 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| microseceszignorootca2009 | 21 avril 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| affirmtrustcommercial | 21 avril 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| comodoecccertificationauthority | 21 avril 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| cadisigrootr2 | 21 avril 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| swisssignsilvercag2 | 21 avril 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| securetrustca | 21 avril 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| cadisigrootr1 | 21 avril 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| accvraiz1 | 21 avril 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| entrustrootcertificationauthority | 21 avril 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| camerfirmaglobalchambersignroot | 21 avril 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| dstacescax6 | 21 avril 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| identrustpublicsectorrootca1 | 21 avril 2018 | BA:29:41:60:77:98:3F:F4:F3:EF:F2:31:05:3B:2E:EA:6D:4D:45:FD | 
| starfieldrootcertificateauthorityg2 | 21 avril 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| secureglobalca | 21 avril 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| eecertificationcentrerootca | 21 avril 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| opentrustrootcag3 | 21 avril 2018 | 6E:26:64:F3:56:BF:34:55:BF:D1:93:3F:7C:01:DE:D8:13:DA:8A:A6 | 
| teliasonerarootcav1 | 21 avril 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| autoridaddecertificacionfirmaprofesionalcifa62634068 | 21 avril 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| opentrustrootcag2 | 21 avril 2018 | 79:5F:88:60:C5:AB:7C:3D:92:E6:CB:F4:8D:E1:45:CD:11:EF:60:0B | 
| opentrustrootcag1 | 21 avril 2018 | 79:91:E8:34:F7:E2:EE:DD:08:95:01:52:E9:55:2D:14:E9:58:D5:7E | 
| globalsigneccrootcar5 | 21 avril 2018 | 1F:24:C6:30:CD:A4:18:EF:20:69:FF:AD:4F:DD:5F:46:3A:1B:69:AA | 
| globalsigneccrootcar4 | 21 avril 2018 | 69:69:56:2E:40:80:F4:24:A1:E7:19:9F:14:BA:F3:EE:58:AB:6A:BB | 
| izenpecom | 21 avril 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| turktrustelektroniksertifikahizmetsaglayicisih5 | 21 avril 2018 | C4:18:F6:4D:46:D1:DF:00:3D:27:30:13:72:43:A9:12:11:C6:75:FB | 
| gdcatrustauthr5root | 21 avril 2018 | 0F:36:38:5B:81:1A:25:C3:9B:31:4E:83:CA:E9:34:66:70:CC:74:B4 | 
| dtrustrootclass3ca22009 | 21 avril 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| quovadisrootca3 | 21 avril 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 21 avril 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| geotrustprimarycertificationauthorityg3 | 21 avril 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycertificationauthorityg2 | 21 avril 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| oistewisekeyglobalrootgbca | 21 avril 2018 | 0F:F9:40:76:18:D3:D7:6A:4B:98:F0:A8:35:9E:0C:FD:27:AC:CC:ED | 
| addtrustexternalroot | 21 avril 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| chambersofcommerceroot2008 | 21 avril 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| digicertglobalrootg3 | 21 avril 2018 | 7E:04:DE:89:6A:3E:66:6D:00:E6:87:D3:3F:FA:D9:3B:E8:3D:34:9E | 
| comodoaaaservicesroot | 21 avril 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| digicertglobalrootg2 | 21 avril 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| certinomisrootca | 21 avril 2018 | 9D:70:BB:01:A5:A4:A0:18:11:2E:F7:1C:01:B9:32:C5:34:E7:88:A8 | 
| oistewisekeyglobalrootgaca | 21 avril 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| dstrootcax3 | 21 avril 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| certigna | 21 avril 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| digicerthighassuranceevrootca | 21 avril 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| soneraclass2rootca | 21 avril 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| trustcorrootcertca2 | 21 avril 2018 | B8:BE:6D:CB:56:F1:55:B9:63:D4:12:CA:4E:06:34:C7:94:B2:1C:C0 | 
| usertrustrsacertificationauthority | 21 avril 2018 | 2B:8F:1B:57:33:0D:BB:A2:D0:7A:6C:51:F7:0E:E9:0D:DA:B9:AD:8E | 
| trustcorrootcertca1 | 21 avril 2018 | FF:BD:CD:E7:82:C8:43:5E:3C:6F:26:86:5C:CA:A8:3A:45:5B:C3:0A | 
| geotrustuniversalca | 21 avril 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| certsignrootca | 21 avril 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| amazonrootca4 | 21 avril 2018 | F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE | 
| amazonrootca3 | 21 avril 2018 | 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E | 
| amazonrootca2 | 21 avril 2018 | 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A | 
| verisignuniversalrootcertificationauthority | 21 avril 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| amazonrootca1 | 21 avril 2018 | 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16 | 
| networksolutionscertificateauthority | 21 avril 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| thawteprimaryrootcag3 | 21 avril 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| affirmtrustnetworking | 21 avril 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| thawteprimaryrootcag2 | 21 avril 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| trustcoreca1 | 21 avril 2018 | 58:D1:DF:95:95:67:6B:63:C0:F0:5B:1C:17:4D:8B:84:0B:C8:78:BD | 
| deutschetelekomrootca2 | 21 avril 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| godaddyrootcertificateauthorityg2 | 21 avril 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| entrustrootcertificationauthorityec1 | 21 avril 2018 | 20:D8:06:40:DF:9B:25:F5:12:25:3A:11:EA:F7:59:8A:EB:14:B5:47 | 
| szafirrootca2 | 21 avril 2018 | E2:52:FA:95:3F:ED:DB:24:60:BD:6E:28:F3:9C:CC:CF:5E:B3:3F:DE | 
| tubitakkamusmsslkoksertifikasisurum1 | 21 avril 2018 | 31:43:64:9B:EC:CE:27:EC:ED:3A:3F:0B:8F:0D:E4:E8:91:DD:EE:CA | 
| buypassclass3rootca | 21 avril 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| comodorsacertificationauthority | 21 avril 2018 | AF:E5:D2:44:A8:D1:19:42:30:FF:47:9F:E2:F8:97:BB:CD:7A:8C:B4 | 
| netlockaranyclassgoldfotanusitvany | 21 avril 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| securitycommunicationrootca2 | 21 avril 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| dtrustrootclass3ca2ev2009 | 21 avril 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| starfieldclass2ca | 21 avril 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| pscprocert | 21 avril 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| actalisauthenticationrootca | 21 avril 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| staatdernederlandenrootcag3 | 21 avril 2018 | D8:EB:6B:41:51:92:59:E0:F3:E7:85:00:C0:3D:B6:88:97:C9:EE:FC | 
| cfcaevroot | 21 avril 2018 | E2:B8:29:4B:55:84:AB:6B:58:C2:90:46:6C:AC:3F:B8:39:8F:84:83 | 
| digicerttrustedrootg4 | 21 avril 2018 | DD:FB:16:CD:49:31:C9:73:A2:03:7D:3F:C8:3A:4D:7D:77:5D:05:E4 | 
| staatdernederlandenrootcag2 | 21 avril 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| securitycommunicationevrootca1 | 21 avril 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| globalsignrootcar3 | 21 avril 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| globalsignrootcar2 | 21 avril 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| certumtrustednetworkca2 | 21 avril 2018 | D3:DD:48:3E:2B:BF:4C:05:E8:AF:10:F5:FA:76:26:CF:D3:DC:30:92 | 
| acraizfnmtrcm | 21 avril 2018 | EC:50:35:07:B2:15:C4:95:62:19:E2:A8:9A:5B:42:99:2C:4C:2C:20 | 
| hellenicacademicandresearchinstitutionseccrootca2015 | 21 avril 2018 | 9F:F1:71:8D:92:D5:9A:F3:7D:74:97:B4:BC:6F:84:68:0B:BA:B6:66 | 
| certplusrootcag2 | 21 avril 2018 | 4F:65:8E:1F:E9:06:D8:28:02:E9:54:47:41:C9:54:25:5D:69:CC:1A | 
| twcarootcertificationauthority | 21 avril 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| twcaglobalrootca | 21 avril 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| certplusrootcag1 | 21 avril 2018 | 22:FD:D0:B7:FD:A2:4E:0D:AC:49:2C:A0:AC:A6:7B:6A:1F:E3:F7:66 | 
| geotrustuniversalca2 | 21 avril 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| baltimorecybertrustroot | 21 avril 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| buypassclass2rootca | 21 avril 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| certumtrustednetworkca | 21 avril 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| digicertassuredidrootg3 | 21 avril 2018 | F5:17:A2:4F:9A:48:C6:C9:F8:A2:00:26:9F:DC:0F:48:2C:AB:30:89 | 
| digicertassuredidrootg2 | 21 avril 2018 | A1:4B:48:D9:43:EE:0A:0E:40:90:4F:3C:E0:A4:C0:91:93:51:5D:3F | 
| isrgrootx1 | 21 avril 2018 | CA:BD:2A:79:A1:07:6A:31:F2:1D:25:36:35:CB:03:9D:43:29:A5:E8 | 
| entrustnetpremium2048secureserverca | 21 avril 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| certplusclass2primaryca | 21 avril 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| digicertglobalrootca | 21 avril 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| entrustrootcertificationauthorityg2 | 21 avril 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| starfieldservicesrootcertificateauthorityg2 | 21 avril 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| thawteprimaryrootca | 21 avril 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| atostrustedroot2011 | 21 avril 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| geotrustglobalca | 21 avril 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| luxtrustglobalroot2 | 21 avril 2018 | 1E:0E:56:19:0A:D1:8B:25:98:B2:04:44:FF:66:8A:04:17:99:5F:3F | 
| etugracertificationauthority | 21 avril 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| visaecommerceroot | 21 avril 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| quovadisrootca | 21 avril 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| identrustcommercialrootca1 | 21 avril 2018 | DF:71:7E:AA:4A:D9:4E:C9:55:84:99:60:2D:48:DE:5F:BC:F0:3A:25 | 
| staatdernederlandenevrootca | 21 avril 2018 | 76:E2:7E:C1:4F:DB:82:C1:C0:A6:75:B5:05:BE:3D:29:B4:ED:DB:BB | 
| ttelesecglobalrootclass3 | 21 avril 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| ttelesecglobalrootclass2 | 21 avril 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| comodocertificationauthority | 21 avril 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| securitycommunicationrootca | 21 avril 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| quovadisrootca3g3 | 21 avril 2018 | 48:12:BD:92:3C:A8:C4:39:06:E7:30:6D:27:96:E6:A4:CF:22:2E:7D | 
| xrampglobalcaroot | 21 avril 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| securesignrootca11 | 21 avril 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| affirmtrustpremium | 21 avril 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| globalsignrootca | 21 avril 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| swisssigngoldcag2 | 21 avril 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| quovadisrootca2g3 | 21 avril 2018 | 09:3C:61:F3:8B:8B:DC:7D:55:DF:75:38:02:05:00:E1:25:F5:C8:36 | 
| affirmtrustpremiumecc | 21 avril 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| geotrustprimarycertificationauthority | 21 avril 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| quovadisrootca1g3 | 21 avril 2018 | 1B:8E:EA:57:96:29:1A:C9:39:EA:B8:0A:81:1A:73:73:C0:93:79:67 | 
| hongkongpostrootca1 | 21 avril 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| usertrustecccertificationauthority | 21 avril 2018 | D1:CB:CA:5D:B2:D5:2A:7F:69:3B:67:4D:E5:F0:5A:1D:0C:95:7D:F0 | 
| cybertrustglobalroot | 21 avril 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| godaddyclass2ca | 21 avril 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| hellenicacademicandresearchinstitutionsrootca2015 | 21 avril 2018 | 01:0C:06:95:A6:98:19:14:FF:BF:5F:C6:B0:B6:95:EA:29:E9:12:A6 | 
| ecacc | 21 avril 2018 | 28:90:3A:63:5B:52:80:FA:E6:77:4C:0B:6D:A7:D6:BA:A6:4A:F2:E8 | 
| hellenicacademicandresearchinstitutionsrootca2011 | 21 avril 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| verisignclass3publicprimarycertificationauthorityg5 | 21 avril 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| verisignclass3publicprimarycertificationauthorityg4 | 21 avril 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3publicprimarycertificationauthorityg3 | 21 avril 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| trustisfpsrootca | 21 avril 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| epkirootcertificationauthority | 21 avril 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| globalchambersignroot2008 | 21 avril 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| camerfirmachambersofcommerceroot | 21 avril 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert81.pem | 13 mars 2014 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| mozillacert99.pem | 13 mars 2014 | F1:7F:6F:B6:31:DC:99:E3:A3:C8:7F:FE:1C:F1:81:10:88:D9:60:33 | 
| mozillacert145.pem | 13 mars 2014 | 10:1D:FA:3F:D5:0B:CB:BB:9B:B5:60:0C:19:55:A4:1A:F4:73:3A:04 | 
| mozillacert37.pem | 13 mars 2014 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert4.pem | 13 mars 2014 | E3:92:51:2F:0A:CF:F5:05:DF:F6:DE:06:7F:75:37:E1:65:EA:57:4B | 
| mozillacert70.pem | 13 mars 2014 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| mozillacert88.pem | 13 mars 2014 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| mozillacert134.pem | 13 mars 2014 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| mozillacert26.pem | 13 mars 2014 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| mozillacert77.pem | 13 mars 2014 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| mozillacert123.pem | 13 mars 2014 | 2A:B6:28:48:5E:78:FB:F3:AD:9E:79:10:DD:6B:DF:99:72:2C:96:E5 | 
| mozillacert15.pem | 13 mars 2014 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| mozillacert66.pem | 13 mars 2014 | DD:E1:D2:A9:01:80:2E:1D:87:5E:84:B3:80:7E:4B:B1:FD:99:41:34 | 
| mozillacert112.pem | 13 mars 2014 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| mozillacert55.pem | 13 mars 2014 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| mozillacert101.pem | 13 mars 2014 | 99:A6:9B:E6:1A:FE:88:6B:4D:2B:82:00:7C:B8:54:FC:31:7E:15:39 | 
| mozillacert119.pem | 13 mars 2014 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| mozillacert44.pem | 13 mars 2014 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| mozillacert108.pem | 13 mars 2014 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| mozillacert95.pem | 13 mars 2014 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert141.pem | 13 mars 2014 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| mozillacert33.pem | 13 mars 2014 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| mozillacert0.pem | 13 mars 2014 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| mozillacert84.pem | 13 mars 2014 | D3:C0:63:F2:19:ED:07:3E:34:AD:5D:75:0B:32:76:29:FF:D5:9A:F2 | 
| mozillacert130.pem | 13 mars 2014 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert148.pem | 13 mars 2014 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| mozillacert22.pem | 13 mars 2014 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| mozillacert7.pem | 13 mars 2014 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| mozillacert73.pem | 13 mars 2014 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| mozillacert137.pem | 13 mars 2014 | 4A:65:D5:F4:1D:EF:39:B8:B8:90:4A:4A:D3:64:81:33:CF:C7:A1:D1 | 
| mozillacert11.pem | 13 mars 2014 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| mozillacert29.pem | 13 mars 2014 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| mozillacert62.pem | 13 mars 2014 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert126.pem | 13 mars 2014 | 25:01:90:19:CF:FB:D9:99:1C:B7:68:25:74:8D:94:5F:30:93:95:42 | 
| mozillacert18.pem | 13 mars 2014 | 79:98:A3:08:E1:4D:65:85:E6:C2:1E:15:3A:71:9F:BA:5A:D3:4A:D9 | 
| mozillacert51.pem | 13 mars 2014 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| mozillacert69.pem | 13 mars 2014 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| mozillacert115.pem | 13 mars 2014 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert40.pem | 13 mars 2014 | 80:25:EF:F4:6E:70:C8:D4:72:24:65:84:FE:40:3B:8A:8D:6A:DB:F5 | 
| mozillacert58.pem | 13 mars 2014 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| mozillacert104.pem | 13 mars 2014 | 4F:99:AA:93:FB:2B:D1:37:26:A1:99:4A:CE:7F:F0:05:F2:93:5D:1E | 
| mozillacert91.pem | 13 mars 2014 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| mozillacert47.pem | 13 mars 2014 | 1B:4B:39:61:26:27:6B:64:91:A2:68:6D:D7:02:43:21:2D:1F:1D:96 | 
| mozillacert80.pem | 13 mars 2014 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert98.pem | 13 mars 2014 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| mozillacert144.pem | 13 mars 2014 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| mozillacert36.pem | 13 mars 2014 | 23:88:C9:D3:71:CC:9E:96:3D:FF:7D:3C:A7:CE:FC:D6:25:EC:19:0D | 
| mozillacert3.pem | 13 mars 2014 | 87:9F:4B:EE:05:DF:98:58:3B:E3:60:D6:33:E7:0D:3F:FE:98:71:AF | 
| mozillacert87.pem | 13 mars 2014 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert133.pem | 13 mars 2014 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| mozillacert25.pem | 13 mars 2014 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| mozillacert76.pem | 13 mars 2014 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert122.pem | 13 mars 2014 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| mozillacert14.pem | 13 mars 2014 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| mozillacert65.pem | 13 mars 2014 | 69:BD:8C:F4:9C:D3:00:FB:59:2E:17:93:CA:55:6A:F3:EC:AA:35:FB | 
| mozillacert111.pem | 13 mars 2014 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| mozillacert129.pem | 13 mars 2014 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| mozillacert54.pem | 13 mars 2014 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| mozillacert100.pem | 13 mars 2014 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| mozillacert118.pem | 13 mars 2014 | 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45 | 
| mozillacert151.pem | 13 mars 2014 | AC:ED:5F:65:53:FD:25:CE:01:5F:1F:7A:48:3B:6A:74:9F:61:78:C6 | 
| mozillacert43.pem | 13 mars 2014 | F9:CD:0E:2C:DA:76:24:C1:8F:BD:F0:F0:AB:B6:45:B8:F7:FE:D5:7A | 
| mozillacert107.pem | 13 mars 2014 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| mozillacert94.pem | 13 mars 2014 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| mozillacert140.pem | 13 mars 2014 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert32.pem | 13 mars 2014 | 60:D6:89:74:B5:C2:65:9E:8A:0F:C1:88:7C:88:D2:46:69:1B:18:2C | 
| mozillacert83.pem | 13 mars 2014 | A0:73:E5:C5:BD:43:61:0D:86:4C:21:13:0A:85:58:57:CC:9C:EA:46 | 
| mozillacert147.pem | 13 mars 2014 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| mozillacert21.pem | 13 mars 2014 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| mozillacert39.pem | 13 mars 2014 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| mozillacert6.pem | 13 mars 2014 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| mozillacert72.pem | 13 mars 2014 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| mozillacert136.pem | 13 mars 2014 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert10.pem | 13 mars 2014 | 5F:3A:FC:0A:8B:64:F6:86:67:34:74:DF:7E:A9:A2:FE:F9:FA:7A:51 | 
| mozillacert28.pem | 13 mars 2014 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| mozillacert61.pem | 13 mars 2014 | E0:B4:32:2E:B2:F6:A5:68:B6:54:53:84:48:18:4A:50:36:87:43:84 | 
| mozillacert79.pem | 13 mars 2014 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert125.pem | 13 mars 2014 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert17.pem | 13 mars 2014 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| mozillacert50.pem | 13 mars 2014 | 8C:96:BA:EB:DD:2B:07:07:48:EE:30:32:66:A0:F3:98:6E:7C:AE:58 | 
| mozillacert68.pem | 13 mars 2014 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| mozillacert114.pem | 13 mars 2014 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert57.pem | 13 mars 2014 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| mozillacert103.pem | 13 mars 2014 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert90.pem | 13 mars 2014 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| mozillacert46.pem | 13 mars 2014 | 40:9D:4B:D9:17:B5:5C:27:B6:9B:64:CB:98:22:44:0D:CD:09:B8:89 | 
| mozillacert97.pem | 13 mars 2014 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| mozillacert143.pem | 13 mars 2014 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| mozillacert35.pem | 13 mars 2014 | 2A:C8:D5:8B:57:CE:BF:2F:49:AF:F2:FC:76:8F:51:14:62:90:7A:41 | 
| mozillacert2.pem | 13 mars 2014 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| mozillacert86.pem | 13 mars 2014 | 74:2C:31:92:E6:07:E4:24:EB:45:49:54:2B:E1:BB:C5:3E:61:74:E2 | 
| mozillacert132.pem | 13 mars 2014 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| mozillacert24.pem | 13 mars 2014 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| mozillacert9.pem | 13 mars 2014 | F4:8B:11:BF:DE:AB:BE:94:54:20:71:E6:41:DE:6B:BE:88:2B:40:B9 | 
| mozillacert75.pem | 13 mars 2014 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| mozillacert121.pem | 13 mars 2014 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| mozillacert139.pem | 13 mars 2014 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| mozillacert13.pem | 13 mars 2014 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| mozillacert64.pem | 13 mars 2014 | 62:7F:8D:78:27:65:63:99:D2:7D:7F:90:44:C9:FE:B3:F3:3E:FA:9A | 
| mozillacert110.pem | 13 mars 2014 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert128.pem | 13 mars 2014 | A9:E9:78:08:14:37:58:88:F2:05:19:B0:6D:2B:0D:2B:60:16:90:7D | 
| mozillacert53.pem | 13 mars 2014 | 7F:8A:B0:CF:D0:51:87:6A:66:F3:36:0F:47:C8:8D:8C:D3:35:FC:74 | 
| mozillacert117.pem | 13 mars 2014 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| mozillacert150.pem | 13 mars 2014 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| mozillacert42.pem | 13 mars 2014 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| mozillacert106.pem | 13 mars 2014 | E7:A1:90:29:D3:D5:52:DC:0D:0F:C6:92:D3:EA:88:0D:15:2E:1A:6B | 
| mozillacert93.pem | 13 mars 2014 | 31:F1:FD:68:22:63:20:EE:C6:3B:3F:9D:EA:4A:3E:53:7C:7C:39:17 | 
| mozillacert31.pem | 13 mars 2014 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| mozillacert49.pem | 13 mars 2014 | 61:57:3A:11:DF:0E:D8:7E:D5:92:65:22:EA:D0:56:D7:44:B3:23:71 | 
| mozillacert82.pem | 13 mars 2014 | 2E:14:DA:EC:28:F0:FA:1E:8E:38:9A:4E:AB:EB:26:C0:0A:D3:83:C3 | 
| mozillacert146.pem | 13 mars 2014 | 21:FC:BD:8E:7F:6C:AF:05:1B:D1:B3:43:EC:A8:E7:61:47:F2:0F:8A | 
| mozillacert20.pem | 13 mars 2014 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert38.pem | 13 mars 2014 | CB:A1:C5:F8:B0:E3:5E:B8:B9:45:12:D3:F9:34:A2:E9:06:10:D3:36 | 
| mozillacert5.pem | 13 mars 2014 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| mozillacert71.pem | 13 mars 2014 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert89.pem | 13 mars 2014 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| mozillacert135.pem | 13 mars 2014 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert27.pem | 13 mars 2014 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| mozillacert60.pem | 13 mars 2014 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| mozillacert78.pem | 13 mars 2014 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert124.pem | 13 mars 2014 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert16.pem | 13 mars 2014 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| mozillacert67.pem | 13 mars 2014 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| mozillacert113.pem | 13 mars 2014 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| mozillacert56.pem | 13 mars 2014 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| mozillacert102.pem | 13 mars 2014 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| mozillacert45.pem | 13 mars 2014 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert109.pem | 13 mars 2014 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| mozillacert96.pem | 13 mars 2014 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| mozillacert142.pem | 13 mars 2014 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| mozillacert34.pem | 13 mars 2014 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| mozillacert1.pem | 13 mars 2014 | 23:E5:94:94:51:95:F2:41:48:03:B4:D5:64:D2:A3:A3:F5:D8:8B:8C | 
| mozillacert85.pem | 13 mars 2014 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| mozillacert131.pem | 13 mars 2014 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| mozillacert149.pem | 13 mars 2014 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert23.pem | 13 mars 2014 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| mozillacert8.pem | 13 mars 2014 | 3E:2B:F7:F2:03:1B:96:F3:8C:E6:C4:D8:A8:5D:3E:2D:58:47:6A:0F | 
| mozillacert74.pem | 13 mars 2014 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert120.pem | 13 mars 2014 | DA:40:18:8B:91:89:A3:ED:EE:AE:DA:97:FE:2F:9D:F5:B7:D1:8A:41 | 
| mozillacert138.pem | 13 mars 2014 | E1:9F:E3:0E:8B:84:60:9E:80:9B:17:0D:72:A8:C5:BA:6E:14:09:BD | 
| mozillacert12.pem | 13 mars 2014 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| mozillacert63.pem | 13 mars 2014 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| mozillacert127.pem | 13 mars 2014 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert19.pem | 13 mars 2014 | B4:35:D4:E1:11:9D:1C:66:90:A7:49:EB:B3:94:BD:63:7B:A7:82:B7 | 
| mozillacert52.pem | 13 mars 2014 | 8B:AF:4C:9B:1D:F0:2A:92:F7:DA:12:8E:B9:1B:AC:F4:98:60:4B:6F | 
| mozillacert116.pem | 13 mars 2014 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert41.pem | 13 mars 2014 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| mozillacert59.pem | 13 mars 2014 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| mozillacert105.pem | 13 mars 2014 | 77:47:4F:C6:30:E4:0F:4C:47:64:3F:84:BA:B8:C6:95:4A:8A:41:EC | 
| mozillacert92.pem | 13 mars 2014 | A3:F1:33:3F:E2:42:BF:CF:C5:D1:4E:8F:39:42:98:40:68:10:D1:A0 | 
| mozillacert30.pem | 13 mars 2014 | E7:B4:F6:9D:61:EC:90:69:DB:7E:90:A7:40:1A:3C:F4:7D:4F:E8:EE | 
| mozillacert48.pem | 13 mars 2014 | A0:A1:AB:90:C9:FC:84:7B:3B:12:61:E8:97:7D:5F:D3:22:61:D3:CC | 
| verisignc4g2.pem | 20 mars 2014 | 0B:77:BE:BB:CB:7A:A2:47:05:DE:CC:0F:BD:6A:02:FC:7A:BD:9B:52 | 
| verisignc2g3.pem | 20 mars 2014 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| verisignc1g6.pem | 31 déc. 2014 | 51:7F:61:1E:29:91:6B:53:82:FB:72:E7:44:D9:8D:C3:CC:53:6D:64 | 
| verisignc2g2.pem | 20 mars 2014 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| verisignroot.pem | 20 mars 2014 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| verisignc2g1.pem | 20 mars 2014 | 67:82:AA:E0:ED:EE:E2:1A:58:39:D3:C0:CD:14:68:0A:4F:60:14:2A | 
| verisignc3g5.pem | 20 mars 2014 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| verisignc1g3.pem | 20 mars 2014 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| verisignc3g4.pem | 20 mars 2014 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignc1g2.pem | 20 mars 2014 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| verisignc3g3.pem | 20 mars 2014 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| verisignc1g1.pem | 20 mars 2014 | 90:AE:A2:69:85:FF:14:80:4C:43:49:52:EC:E9:60:84:77:AF:55:6F | 
| verisignc3g2.pem | 20 mars 2014 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| verisignc3g1.pem | 20 mars 2014 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| verisignc2g6.pem | 31 déc. 2014 | 40:B3:31:A0:E9:BF:E8:55:BC:39:93:CA:70:4F:4E:C2:51:D4:1D:8F | 
| verisignc4g3.pem | 20 mars 2014 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| gdroot-g2.pem | 31 déc. 2014 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| gd-class2-root.pem | 31 déc. 2014 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| gd\$1bundle-g2.pem | 31 déc. 2014 | 27:AC:93:69:FA:F2:52:07:BB:26:27:CE:FA:CC:BE:4E:F9:C3:19:B8 | 
| dstacescax6 | 18 juin 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| gd\$1bundle-g2.pem | 18 juin 2018 | 27:AC:93:69:FA:F2:52:07:BB:26:27:CE:FA:CC:BE:4E:F9:C3:19:B8 | 
| verisignc4g3.pem | 18 juin 2018 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| swisssignplatinumg2ca | 21 avril 2018 | 56:E0:FA:C0:3B:8F:18:23:55:18:E5:D3:11:CA:E8:C2:43:31:AB:66 | 
| geotrustprimarycertificationauthorityg3 | 18 juin 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycertificationauthorityg2 | 18 juin 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| buypassclass2rootca | 18 juin 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| camerfirmachambersofcommerceroot | 18 juin 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert20.pem | 18 juin 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert12.pem | 18 juin 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| mozillacert90.pem | 18 juin 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| mozillacert82.pem | 18 juin 2018 | 2E:14:DA:EC:28:F0:FA:1E:8E:38:9A:4E:AB:EB:26:C0:0A:D3:83:C3 | 
| mozillacert140.pem | 18 juin 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert74.pem | 18 juin 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert132.pem | 18 juin 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| mozillacert66.pem | 18 juin 2018 | DD:E1:D2:A9:01:80:2E:1D:87:5E:84:B3:80:7E:4B:B1:FD:99:41:34 | 
| mozillacert124.pem | 18 juin 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert58.pem | 18 juin 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| securitycommunicationrootca2 | 18 juin 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert116.pem | 18 juin 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert108.pem | 18 juin 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| certigna | 18 juin 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert3.pem | 18 juin 2018 | 87:9F:4B:EE:05:DF:98:58:3B:E3:60:D6:33:E7:0D:3F:FE:98:71:AF | 
| verisignc1g1.pem | 18 juin 2018 | 90:AE:A2:69:85:FF:14:80:4C:43:49:52:EC:E9:60:84:77:AF:55:6F | 
| verisignc4g2.pem | 18 juin 2018 | 0B:77:BE:BB:CB:7A:A2:47:05:DE:CC:0F:BD:6A:02:FC:7A:BD:9B:52 | 
| deutschetelekomrootca2 | 18 juin 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| starfieldrootg2ca | 21 avril 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| comodoecccertificationauthority | 18 juin 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| digicertglobalrootg3 | 18 juin 2018 | 7E:04:DE:89:6A:3E:66:6D:00:E6:87:D3:3F:FA:D9:3B:E8:3D:34:9E | 
| digicertglobalrootg2 | 18 juin 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| mozillacert11.pem | 18 juin 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| mozillacert81.pem | 18 juin 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| mozillacert73.pem | 18 juin 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| szafirrootca2 | 18 juin 2018 | E2:52:FA:95:3F:ED:DB:24:60:BD:6E:28:F3:9C:CC:CF:5E:B3:3F:DE | 
| mozillacert131.pem | 18 juin 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| ecacc | 18 juin 2018 | 28:90:3A:63:5B:52:80:FA:E6:77:4C:0B:6D:A7:D6:BA:A6:4A:F2:E8 | 
| mozillacert65.pem | 18 juin 2018 | 69:BD:8C:F4:9C:D3:00:FB:59:2E:17:93:CA:55:6A:F3:EC:AA:35:FB | 
| turktrustelektroniksertifikahizmetsaglayicisih5 | 18 juin 2018 | C4:18:F6:4D:46:D1:DF:00:3D:27:30:13:72:43:A9:12:11:C6:75:FB | 
| mozillacert123.pem | 18 juin 2018 | 2A:B6:28:48:5E:78:FB:F3:AD:9E:79:10:DD:6B:DF:99:72:2C:96:E5 | 
| mozillacert57.pem | 18 juin 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| mozillacert115.pem | 18 juin 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert49.pem | 18 juin 2018 | 61:57:3A:11:DF:0E:D8:7E:D5:92:65:22:EA:D0:56:D7:44:B3:23:71 | 
| mozillacert107.pem | 18 juin 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| verisignclass3g4ca | 21 avril 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| securetrustca | 18 juin 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| mozillacert2.pem | 18 juin 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| buypassclass2ca | 21 avril 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| secomscrootca2 | 21 avril 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| secomscrootca1 | 21 avril 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| trustisfpsrootca | 18 juin 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| hongkongpostrootca1 | 18 juin 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| certsignrootca | 18 juin 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| geotrustprimaryca | 21 avril 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| twcaglobalrootca | 18 juin 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| camerfirmachambersca | 21 avril 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| mozillacert10.pem | 18 juin 2018 | 5F:3A:FC:0A:8B:64:F6:86:67:34:74:DF:7E:A9:A2:FE:F9:FA:7A:51 | 
| mozillacert80.pem | 18 juin 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert72.pem | 18 juin 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| comodoaaaca | 21 avril 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert130.pem | 18 juin 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert64.pem | 18 juin 2018 | 62:7F:8D:78:27:65:63:99:D2:7D:7F:90:44:C9:FE:B3:F3:3E:FA:9A | 
| mozillacert122.pem | 18 juin 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| mozillacert56.pem | 18 juin 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| equifaxsecureebusinessca1 | 21 avril 2018 | AE:E6:3D:70:E3:76:FB:C7:3A:EB:B0:A1:C1:D4:C4:7A:A7:40:B3:F4 | 
| camerfirmachambersignca | 21 avril 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert114.pem | 18 juin 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert48.pem | 18 juin 2018 | A0:A1:AB:90:C9:FC:84:7B:3B:12:61:E8:97:7D:5F:D3:22:61:D3:CC | 
| pscprocert | 18 juin 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert106.pem | 18 juin 2018 | E7:A1:90:29:D3:D5:52:DC:0D:0F:C6:92:D3:EA:88:0D:15:2E:1A:6B | 
| mozillacert1.pem | 18 juin 2018 | 23:E5:94:94:51:95:F2:41:48:03:B4:D5:64:D2:A3:A3:F5:D8:8B:8C | 
| eecertificationcentrerootca | 18 juin 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| digicertglobalrootca | 18 juin 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| thawteprimaryrootcag3 | 18 juin 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| thawteprimaryrootcag2 | 18 juin 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| entrustrootcertificationauthorityec1 | 18 juin 2018 | 20:D8:06:40:DF:9B:25:F5:12:25:3A:11:EA:F7:59:8A:EB:14:B5:47 | 
| valicertclass2ca | 21 avril 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| globalchambersignroot2008 | 18 juin 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| amazonrootca4 | 18 juin 2018 | F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE | 
| gd-class2-root.pem | 18 juin 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| amazonrootca3 | 18 juin 2018 | 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E | 
| amazonrootca2 | 18 juin 2018 | 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A | 
| securitycommunicationrootca | 18 juin 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| amazonrootca1 | 18 juin 2018 | 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16 | 
| acraizfnmtrcm | 18 juin 2018 | EC:50:35:07:B2:15:C4:95:62:19:E2:A8:9A:5B:42:99:2C:4C:2C:20 | 
| quovadisrootca3g3 | 18 juin 2018 | 48:12:BD:92:3C:A8:C4:39:06:E7:30:6D:27:96:E6:A4:CF:22:2E:7D | 
| certplusrootcag2 | 18 juin 2018 | 4F:65:8E:1F:E9:06:D8:28:02:E9:54:47:41:C9:54:25:5D:69:CC:1A | 
| certplusrootcag1 | 18 juin 2018 | 22:FD:D0:B7:FD:A2:4E:0D:AC:49:2C:A0:AC:A6:7B:6A:1F:E3:F7:66 | 
| mozillacert71.pem | 18 juin 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert63.pem | 18 juin 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| mozillacert121.pem | 18 juin 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| ttelesecglobalrootclass3ca | 21 avril 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| mozillacert55.pem | 18 juin 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| mozillacert113.pem | 18 juin 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| baltimorecybertrustca | 21 avril 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| mozillacert47.pem | 18 juin 2018 | 1B:4B:39:61:26:27:6B:64:91:A2:68:6D:D7:02:43:21:2D:1F:1D:96 | 
| mozillacert105.pem | 18 juin 2018 | 77:47:4F:C6:30:E4:0F:4C:47:64:3F:84:BA:B8:C6:95:4A:8A:41:EC | 
| mozillacert39.pem | 18 juin 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| usertrustecccertificationauthority | 18 juin 2018 | D1:CB:CA:5D:B2:D5:2A:7F:69:3B:67:4D:E5:F0:5A:1D:0C:95:7D:F0 | 
| mozillacert0.pem | 18 juin 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| securitycommunicationevrootca1 | 18 juin 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| verisignc3g5.pem | 18 juin 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| globalsignr3ca | 21 avril 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| trustcoreca1 | 18 juin 2018 | 58:D1:DF:95:95:67:6B:63:C0:F0:5B:1C:17:4D:8B:84:0B:C8:78:BD | 
| equifaxsecureglobalebusinessca1 | 21 avril 2018 | 3A:74:CB:7A:47:DB:70:DE:89:1F:24:35:98:64:B8:2D:82:BD:1A:36 | 
| geotrustuniversalca | 18 juin 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| affirmtrustpremiumca | 21 avril 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| staatdernederlandenrootcag3 | 18 juin 2018 | D8:EB:6B:41:51:92:59:E0:F3:E7:85:00:C0:3D:B6:88:97:C9:EE:FC | 
| staatdernederlandenrootcag2 | 18 juin 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| mozillacert70.pem | 18 juin 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| secomevrootca1 | 21 avril 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| geotrustglobalca | 18 juin 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert62.pem | 18 juin 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert120.pem | 18 juin 2018 | DA:40:18:8B:91:89:A3:ED:EE:AE:DA:97:FE:2F:9D:F5:B7:D1:8A:41 | 
| mozillacert54.pem | 18 juin 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| mozillacert112.pem | 18 juin 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| mozillacert46.pem | 18 juin 2018 | 40:9D:4B:D9:17:B5:5C:27:B6:9B:64:CB:98:22:44:0D:CD:09:B8:89 | 
| swisssigngoldcag2 | 18 juin 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert104.pem | 18 juin 2018 | 4F:99:AA:93:FB:2B:D1:37:26:A1:99:4A:CE:7F:F0:05:F2:93:5D:1E | 
| mozillacert38.pem | 18 juin 2018 | CB:A1:C5:F8:B0:E3:5E:B8:B9:45:12:D3:F9:34:A2:E9:06:10:D3:36 | 
| certplusclass3pprimaryca | 21 avril 2018 | 21:6B:2A:29:E6:2A:00:CE:82:01:46:D8:24:41:41:B9:25:11:B2:79 | 
| entrustrootcertificationauthorityg2 | 18 juin 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| godaddyrootg2ca | 21 avril 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| cfcaevroot | 18 juin 2018 | E2:B8:29:4B:55:84:AB:6B:58:C2:90:46:6C:AC:3F:B8:39:8F:84:83 | 
| verisignc3g4.pem | 18 juin 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| geotrustuniversalca2 | 18 juin 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| starfieldservicesrootg2ca | 21 avril 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| digicerthighassuranceevrootca | 18 juin 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| entrustnetpremium2048secureserverca | 18 juin 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| camerfirmaglobalchambersignroot | 18 juin 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| verisignclass3g3ca | 21 avril 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| godaddyclass2ca | 18 juin 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| mozillacert61.pem | 18 juin 2018 | E0:B4:32:2E:B2:F6:A5:68:B6:54:53:84:48:18:4A:50:36:87:43:84 | 
| mozillacert53.pem | 18 juin 2018 | 7F:8A:B0:CF:D0:51:87:6A:66:F3:36:0F:47:C8:8D:8C:D3:35:FC:74 | 
| atostrustedroot2011 | 18 juin 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert111.pem | 18 juin 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| staatdernederlandenevrootca | 18 juin 2018 | 76:E2:7E:C1:4F:DB:82:C1:C0:A6:75:B5:05:BE:3D:29:B4:ED:DB:BB | 
| mozillacert45.pem | 18 juin 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert103.pem | 18 juin 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert37.pem | 18 juin 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert29.pem | 18 juin 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| izenpecom | 18 juin 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| comodorsacertificationauthority | 18 juin 2018 | AF:E5:D2:44:A8:D1:19:42:30:FF:47:9F:E2:F8:97:BB:CD:7A:8C:B4 | 
| mozillacert99.pem | 18 juin 2018 | F1:7F:6F:B6:31:DC:99:E3:A3:C8:7F:FE:1C:F1:81:10:88:D9:60:33 | 
| mozillacert149.pem | 18 juin 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| utnuserfirstobjectca | 21 avril 2018 | E1:2D:FB:4B:41:D7:D9:C3:2B:30:51:4B:AC:1D:81:D8:38:5E:2D:46 | 
| verisignc3g3.pem | 18 juin 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| dstrootcax3 | 18 juin 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| addtrustexternalroot | 18 juin 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| certumtrustednetworkca | 18 juin 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| affirmtrustpremiumecc | 18 juin 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| starfieldclass2ca | 18 juin 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| actalisauthenticationrootca | 18 juin 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| verisignclass2g3ca | 21 avril 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| isrgrootx1 | 18 juin 2018 | CA:BD:2A:79:A1:07:6A:31:F2:1D:25:36:35:CB:03:9D:43:29:A5:E8 | 
| godaddyrootcertificateauthorityg2 | 18 juin 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| mozillacert60.pem | 18 juin 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| chunghwaepkirootca | 21 avril 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert52.pem | 18 juin 2018 | 8B:AF:4C:9B:1D:F0:2A:92:F7:DA:12:8E:B9:1B:AC:F4:98:60:4B:6F | 
| microseceszignorootca2009 | 18 juin 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| securesignrootca11 | 18 juin 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| mozillacert110.pem | 18 juin 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert44.pem | 18 juin 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| mozillacert102.pem | 18 juin 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| mozillacert36.pem | 18 juin 2018 | 23:88:C9:D3:71:CC:9E:96:3D:FF:7D:3C:A7:CE:FC:D6:25:EC:19:0D | 
| mozillacert28.pem | 18 juin 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| baltimorecybertrustroot | 18 juin 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| amzninternalrootca | 12 déc. 2008 | A7:B7:F6:15:8A:FF:1E:C8:85:13:38:BC:93:EB:A2:AB:A4:09:EF:06 | 
| mozillacert98.pem | 18 juin 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| mozillacert148.pem | 18 juin 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| verisignc3g2.pem | 18 juin 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| quovadisrootca2g3 | 18 juin 2018 | 09:3C:61:F3:8B:8B:DC:7D:55:DF:75:38:02:05:00:E1:25:F5:C8:36 | 
| geotrustprimarycertificationauthority | 18 juin 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| opentrustrootcag3 | 18 juin 2018 | 6E:26:64:F3:56:BF:34:55:BF:D1:93:3F:7C:01:DE:D8:13:DA:8A:A6 | 
| opentrustrootcag2 | 18 juin 2018 | 79:5F:88:60:C5:AB:7C:3D:92:E6:CB:F4:8D:E1:45:CD:11:EF:60:0B | 
| opentrustrootcag1 | 18 juin 2018 | 79:91:E8:34:F7:E2:EE:DD:08:95:01:52:E9:55:2D:14:E9:58:D5:7E | 
| verisignclass3ca | 21 avril 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| globalsignca | 21 avril 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| ttelesecglobalrootclass2ca | 21 avril 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| verisignclass1g3ca | 21 avril 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| verisignuniversalrootca | 21 avril 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| soneraclass2ca | 21 avril 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| starfieldservicesrootcertificateauthorityg2 | 18 juin 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert51.pem | 18 juin 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| mozillacert43.pem | 18 juin 2018 | F9:CD:0E:2C:DA:76:24:C1:8F:BD:F0:F0:AB:B6:45:B8:F7:FE:D5:7A | 
| mozillacert101.pem | 18 juin 2018 | 99:A6:9B:E6:1A:FE:88:6B:4D:2B:82:00:7C:B8:54:FC:31:7E:15:39 | 
| mozillacert35.pem | 18 juin 2018 | 2A:C8:D5:8B:57:CE:BF:2F:49:AF:F2:FC:76:8F:51:14:62:90:7A:41 | 
| globalsignr2ca | 21 avril 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| mozillacert27.pem | 18 juin 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| affirmtrustpremium | 18 juin 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert19.pem | 18 juin 2018 | B4:35:D4:E1:11:9D:1C:66:90:A7:49:EB:B3:94:BD:63:7B:A7:82:B7 | 
| mozillacert97.pem | 18 juin 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| netlockaranyclassgoldfotanusitvany | 18 juin 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| mozillacert89.pem | 18 juin 2018 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| verisignroot.pem | 18 juin 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| mozillacert147.pem | 18 juin 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| aolrootca2 | 21 avril 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| cia-crt-g3-01-ca | 23 novembre 2016 | 2B:EE:2C:BA:A3:1D:B5:FE:60:40:41:95:08:ED:46:82:39:4D:ED:E2 | 
| aolrootca1 | 21 avril 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| verisignc3g1.pem | 18 juin 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert139.pem | 18 juin 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| soneraclass2rootca | 18 juin 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| swisssignsilverg2ca | 21 avril 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| thawteprimaryrootca | 18 juin 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| gdcatrustauthr5root | 18 juin 2018 | 0F:36:38:5B:81:1A:25:C3:9B:31:4E:83:CA:E9:34:66:70:CC:74:B4 | 
| trustcenterclass4caii | 21 avril 2018 | A6:9A:91:FD:05:7F:13:6A:42:63:0B:B1:76:0D:2D:51:12:0C:16:50 | 
| usertrustrsacertificationauthority | 18 juin 2018 | 2B:8F:1B:57:33:0D:BB:A2:D0:7A:6C:51:F7:0E:E9:0D:DA:B9:AD:8E | 
| digicertassuredidrootg3 | 18 juin 2018 | F5:17:A2:4F:9A:48:C6:C9:F8:A2:00:26:9F:DC:0F:48:2C:AB:30:89 | 
| digicertassuredidrootg2 | 18 juin 2018 | A1:4B:48:D9:43:EE:0A:0E:40:90:4F:3C:E0:A4:C0:91:93:51:5D:3F | 
| mozillacert50.pem | 18 juin 2018 | 8C:96:BA:EB:DD:2B:07:07:48:EE:30:32:66:A0:F3:98:6E:7C:AE:58 | 
| mozillacert42.pem | 18 juin 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| mozillacert100.pem | 18 juin 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| mozillacert34.pem | 18 juin 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| affirmtrustcommercialca | 21 avril 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert26.pem | 18 juin 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| globalsigneccrootcar5 | 18 juin 2018 | 1F:24:C6:30:CD:A4:18:EF:20:69:FF:AD:4F:DD:5F:46:3A:1B:69:AA | 
| globalsigneccrootcar4 | 18 juin 2018 | 69:69:56:2E:40:80:F4:24:A1:E7:19:9F:14:BA:F3:EE:58:AB:6A:BB | 
| buypassclass3rootca | 18 juin 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert18.pem | 18 juin 2018 | 79:98:A3:08:E1:4D:65:85:E6:C2:1E:15:3A:71:9F:BA:5A:D3:4A:D9 | 
| mozillacert96.pem | 18 juin 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| verisignc2g6.pem | 18 juin 2018 | 40:B3:31:A0:E9:BF:E8:55:BC:39:93:CA:70:4F:4E:C2:51:D4:1D:8F | 
| secomvalicertclass1ca | 21 avril 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert88.pem | 18 juin 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| accvraiz1 | 18 juin 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert146.pem | 18 juin 2018 | 21:FC:BD:8E:7F:6C:AF:05:1B:D1:B3:43:EC:A8:E7:61:47:F2:0F:8A | 
| mozillacert138.pem | 18 juin 2018 | E1:9F:E3:0E:8B:84:60:9E:80:9B:17:0D:72:A8:C5:BA:6E:14:09:BD | 
| verisignclass3g2ca | 21 avril 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| dtrustrootclass3ca2ev2009 | 18 juin 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| xrampglobalca | 21 avril 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| mozillacert9.pem | 18 juin 2018 | F4:8B:11:BF:DE:AB:BE:94:54:20:71:E6:41:DE:6B:BE:88:2B:40:B9 | 
| verisignuniversalrootcertificationauthority | 18 juin 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| tubitakkamusmsslkoksertifikasisurum1 | 18 juin 2018 | 31:43:64:9B:EC:CE:27:EC:ED:3A:3F:0B:8F:0D:E4:E8:91:DD:EE:CA | 
| mozillacert41.pem | 18 juin 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| mozillacert33.pem | 18 juin 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| mozillacert25.pem | 18 juin 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| mozillacert17.pem | 18 juin 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| mozillacert95.pem | 18 juin 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| affirmtrustpremiumeccca | 21 avril 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert87.pem | 18 juin 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert145.pem | 18 juin 2018 | 10:1D:FA:3F:D5:0B:CB:BB:9B:B5:60:0C:19:55:A4:1A:F4:73:3A:04 | 
| mozillacert79.pem | 18 juin 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert137.pem | 18 juin 2018 | 4A:65:D5:F4:1D:EF:39:B8:B8:90:4A:4A:D3:64:81:33:CF:C7:A1:D1 | 
| digicertassuredidrootca | 18 juin 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| addtrustqualifiedca | 21 avril 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert129.pem | 18 juin 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| verisignclass2g2ca | 21 avril 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| baltimorecodesigningca | 21 avril 2018 | 30:46:D8:C8:88:FF:69:30:C3:4A:FC:CD:49:27:08:7C:60:56:7B:0D | 
| luxtrustglobalroot2 | 18 juin 2018 | 1E:0E:56:19:0A:D1:8B:25:98:B2:04:44:FF:66:8A:04:17:99:5F:3F | 
| visaecommerceroot | 18 juin 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| oistewisekeyglobalrootgbca | 18 juin 2018 | 0F:F9:40:76:18:D3:D7:6A:4B:98:F0:A8:35:9E:0C:FD:27:AC:CC:ED | 
| mozillacert8.pem | 18 juin 2018 | 3E:2B:F7:F2:03:1B:96:F3:8C:E6:C4:D8:A8:5D:3E:2D:58:47:6A:0F | 
| comodocertificationauthority | 18 juin 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| cia-crt-g3-02-ca | 23 novembre 2016 | 96:4A:BB:A7:BD:DA:FC:97:34:C0:0A:2D:F0:05:98:F7:E6:C6:6F:09 | 
| verisignc1g6.pem | 18 juin 2018 | 51:7F:61:1E:29:91:6B:53:82:FB:72:E7:44:D9:8D:C3:CC:53:6D:64 | 
| trustcenterclass2caii | 21 avril 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| quovadisrootca1g3 | 18 juin 2018 | 1B:8E:EA:57:96:29:1A:C9:39:EA:B8:0A:81:1A:73:73:C0:93:79:67 | 
| mozillacert40.pem | 18 juin 2018 | 80:25:EF:F4:6E:70:C8:D4:72:24:65:84:FE:40:3B:8A:8D:6A:DB:F5 | 
| cadisigrootr2 | 18 juin 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| cadisigrootr1 | 18 juin 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| mozillacert32.pem | 18 juin 2018 | 60:D6:89:74:B5:C2:65:9E:8A:0F:C1:88:7C:88:D2:46:69:1B:18:2C | 
| utndatacorpsgcca | 21 avril 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| mozillacert24.pem | 18 juin 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| addtrustclass1ca | 21 avril 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| mozillacert16.pem | 18 juin 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| affirmtrustnetworkingca | 21 avril 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert94.pem | 18 juin 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| mozillacert86.pem | 18 juin 2018 | 74:2C:31:92:E6:07:E4:24:EB:45:49:54:2B:E1:BB:C5:3E:61:74:E2 | 
| mozillacert144.pem | 18 juin 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| mozillacert78.pem | 18 juin 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert136.pem | 18 juin 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert128.pem | 18 juin 2018 | A9:E9:78:08:14:37:58:88:F2:05:19:B0:6D:2B:0D:2B:60:16:90:7D | 
| verisignclass1g2ca | 21 avril 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| hellenicacademicandresearchinstitutionsrootca2015 | 18 juin 2018 | 01:0C:06:95:A6:98:19:14:FF:BF:5F:C6:B0:B6:95:EA:29:E9:12:A6 | 
| soneraclass1ca | 21 avril 2018 | 07:47:22:01:99:CE:74:B9:7C:B0:3D:79:B2:64:A2:C8:55:E9:33:FF | 
| hellenicacademicandresearchinstitutionsrootca2011 | 18 juin 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| certumtrustednetworkca2 | 18 juin 2018 | D3:DD:48:3E:2B:BF:4C:05:E8:AF:10:F5:FA:76:26:CF:D3:DC:30:92 | 
| equifaxsecureca | 21 avril 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| thawteserverca | 21 avril 2018 | 9F:AD:91:A6:CE:6A:C6:C5:00:47:C4:4E:C9:D4:A5:0D:92:D8:49:79 | 
| mozillacert7.pem | 18 juin 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| affirmtrustnetworking | 18 juin 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| deprecateditsecca | 27 janvier 2012 | 12:12:0B:03:0E:15:14:54:F4:DD:B3:F5:DE:13:6E:83:5A:29:72:9D | 
| globalsignrootcar3 | 18 juin 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| globalsignrootcar2 | 18 juin 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| quovadisrootca | 18 juin 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| mozillacert31.pem | 18 juin 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| entrustrootcertificationauthority | 18 juin 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert23.pem | 18 juin 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| mozillacert15.pem | 18 juin 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| verisignc2g3.pem | 18 juin 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| mozillacert93.pem | 18 juin 2018 | 31:F1:FD:68:22:63:20:EE:C6:3B:3F:9D:EA:4A:3E:53:7C:7C:39:17 | 
| mozillacert151.pem | 18 juin 2018 | AC:ED:5F:65:53:FD:25:CE:01:5F:1F:7A:48:3B:6A:74:9F:61:78:C6 | 
| mozillacert85.pem | 18 juin 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| certplusclass2primaryca | 18 juin 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| mozillacert143.pem | 18 juin 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| mozillacert77.pem | 18 juin 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| mozillacert135.pem | 18 juin 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert69.pem | 18 juin 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| mozillacert127.pem | 18 juin 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert119.pem | 18 juin 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| geotrustprimarycag3 | 21 avril 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| identrustpublicsectorrootca1 | 18 juin 2018 | BA:29:41:60:77:98:3F:F4:F3:EF:F2:31:05:3B:2E:EA:6D:4D:45:FD | 
| geotrustprimarycag2 | 21 avril 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| trustcorrootcertca2 | 18 juin 2018 | B8:BE:6D:CB:56:F1:55:B9:63:D4:12:CA:4E:06:34:C7:94:B2:1C:C0 | 
| mozillacert6.pem | 18 juin 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| trustcorrootcertca1 | 18 juin 2018 | FF:BD:CD:E7:82:C8:43:5E:3C:6F:26:86:5C:CA:A8:3A:45:5B:C3:0A | 
| networksolutionscertificateauthority | 18 juin 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| twcarootcertificationauthority | 18 juin 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| addtrustexternalca | 21 avril 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| verisignclass3g5ca | 21 avril 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| autoridaddecertificacionfirmaprofesionalcifa62634068 | 18 juin 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| hellenicacademicandresearchinstitutionseccrootca2015 | 18 juin 2018 | 9F:F1:71:8D:92:D5:9A:F3:7D:74:97:B4:BC:6F:84:68:0B:BA:B6:66 | 
| verisigntsaca | 21 avril 2018 | 20:CE:B1:F0:F5:1C:0E:19:A9:F3:8D:B1:AA:8E:03:8C:AA:7A:C7:01 | 
| utnuserfirsthardwareca | 21 avril 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| identrustcommercialrootca1 | 18 juin 2018 | DF:71:7E:AA:4A:D9:4E:C9:55:84:99:60:2D:48:DE:5F:BC:F0:3A:25 | 
| dtrustrootclass3ca22009 | 18 juin 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| epkirootcertificationauthority | 18 juin 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert30.pem | 18 juin 2018 | E7:B4:F6:9D:61:EC:90:69:DB:7E:90:A7:40:1A:3C:F4:7D:4F:E8:EE | 
| teliasonerarootcav1 | 18 juin 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| buypassclass3ca | 21 avril 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert22.pem | 18 juin 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| mozillacert14.pem | 18 juin 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| verisignc2g2.pem | 18 juin 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| certumca | 21 avril 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert92.pem | 18 juin 2018 | A3:F1:33:3F:E2:42:BF:CF:C5:D1:4E:8F:39:42:98:40:68:10:D1:A0 | 
| mozillacert150.pem | 18 juin 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| mozillacert84.pem | 18 juin 2018 | D3:C0:63:F2:19:ED:07:3E:34:AD:5D:75:0B:32:76:29:FF:D5:9A:F2 | 
| ttelesecglobalrootclass3 | 18 juin 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| globalsignrootca | 18 juin 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| ttelesecglobalrootclass2 | 18 juin 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert142.pem | 18 juin 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| mozillacert76.pem | 18 juin 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert134.pem | 18 juin 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| mozillacert68.pem | 18 juin 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| etugracertificationauthority | 18 juin 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert126.pem | 18 juin 2018 | 25:01:90:19:CF:FB:D9:99:1C:B7:68:25:74:8D:94:5F:30:93:95:42 | 
| keynectisrootca | 21 avril 2018 | 9C:61:5C:4D:4D:85:10:3A:53:26:C2:4D:BA:EA:E4:A2:D2:D5:CC:97 | 
| mozillacert118.pem | 18 juin 2018 | 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45 | 
| quovadisrootca3 | 18 juin 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 18 juin 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert5.pem | 18 juin 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| verisignc1g3.pem | 18 juin 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| cybertrustglobalroot | 18 juin 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| amzninternalinfoseccag3 | 27 février 2015 | B9:B1:CA:38:F7:BF:9C:D2:D4:95:E7:B6:5E:75:32:9B:A8:78:2E:F6 | 
| starfieldrootcertificateauthorityg2 | 18 juin 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| entrust2048ca | 21 avril 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| swisssignsilvercag2 | 18 juin 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| affirmtrustcommercial | 18 juin 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| certinomisrootca | 18 juin 2018 | 9D:70:BB:01:A5:A4:A0:18:11:2E:F7:1C:01:B9:32:C5:34:E7:88:A8 | 
| xrampglobalcaroot | 18 juin 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| secureglobalca | 18 juin 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| swisssigngoldg2ca | 21 avril 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert21.pem | 18 juin 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| mozillacert13.pem | 18 juin 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| verisignc2g1.pem | 18 juin 2018 | 67:82:AA:E0:ED:EE:E2:1A:58:39:D3:C0:CD:14:68:0A:4F:60:14:2A | 
| mozillacert91.pem | 18 juin 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| oistewisekeyglobalrootgaca | 18 juin 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| mozillacert83.pem | 18 juin 2018 | A0:73:E5:C5:BD:43:61:0D:86:4C:21:13:0A:85:58:57:CC:9C:EA:46 | 
| entrustevca | 21 avril 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert141.pem | 18 juin 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| mozillacert75.pem | 18 juin 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| mozillacert133.pem | 18 juin 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| mozillacert67.pem | 18 juin 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| mozillacert125.pem | 18 juin 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert59.pem | 18 juin 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| thawtepremiumserverca | 21 avril 2018 | E0:AB:05:94:20:72:54:93:05:60:62:02:36:70:F7:CD:2E:FC:66:66 | 
| mozillacert117.pem | 18 juin 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| utnuserfirstclientauthemailca | 21 avril 2018 | B1:72:B1:A5:6D:95:F9:1F:E5:02:87:E1:4D:37:EA:6A:44:63:76:8A | 
| entrustrootcag2 | 21 avril 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| mozillacert109.pem | 18 juin 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| digicerttrustedrootg4 | 18 juin 2018 | DD:FB:16:CD:49:31:C9:73:A2:03:7D:3F:C8:3A:4D:7D:77:5D:05:E4 | 
| gdroot-g2.pem | 18 juin 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| comodoaaaservicesroot | 18 juin 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert4.pem | 18 juin 2018 | E3:92:51:2F:0A:CF:F5:05:DF:F6:DE:06:7F:75:37:E1:65:EA:57:4B | 
| verisignclass3publicprimarycertificationauthorityg5 | 18 juin 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| chambersofcommerceroot2008 | 18 juin 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| verisignclass3publicprimarycertificationauthorityg4 | 18 juin 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3publicprimarycertificationauthorityg3 | 18 juin 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| thawtepersonalfreemailca | 21 avril 2018 | E6:18:83:AE:84:CA:C1:C1:CD:52:AD:E8:E9:25:2B:45:A6:4F:B7:E2 | 
| verisignc1g2.pem | 18 juin 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| gtecybertrustglobalca | 21 avril 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| trustcenteruniversalcai | 21 avril 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| camerfirmachamberscommerceca | 21 avril 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| verisignclass1ca | 21 avril 2018 | CE:6A:64:A3:09:E4:2F:BB:D9:85:1C:45:3E:64:09:EA:E8:7D:60:F1 | 

# AWS AppSync journal des modifications du modèle de mappage du résolveur
<a name="resolver-mapping-template-changelog"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Les modèles de mappage des résolveurs et des fonctions sont versionnés. La version du modèle de mappage `2018-05-29` (telle que) impose ce qui suit :
+ La forme attendue de la configuration de demande de source de données fournie par le modèle de demande
+ Le comportement d'exécution du modèle de mappage des demandes et du modèle de mappage des réponses

Les versions sont représentées selon le YYYY-MM-DD format, une date ultérieure correspond à une version plus récente. Cette page répertorie les différences entre les versions de modèles de mappage actuellement prises en charge dans AWS AppSync.

**Topics**
+ [Disponibilité des opérations de sources de données par matrice de version](#aws-appsync-resolver-mapping-template-operation-availability-per-version)
+ [Modification de la version sur un modèle de mappage de résolveur d'unité](#changing-the-version-on-a-unit-resolver-mapping-template)
+ [Modification de la version sur une fonction](#changing-the-version-on-a-function)
+ [2018-05-29](#aws-appsync-resolver-mapping-template-version-2018-05-29)
+ [2017-02-28](#aws-appsync-resolver-mapping-template-version-2017-02-28)

## Disponibilité des opérations de sources de données par matrice de version
<a name="aws-appsync-resolver-mapping-template-operation-availability-per-version"></a>


| Opération/Version prise en charge | 2017-02-28 | 2018-05-29 | 
| --- | --- | --- | 
|  AWS Lambda Invoquer  |  Oui  |  Oui  | 
|  AWS Lambda BatchInvoke  |  Oui  |  Oui  | 
|  Aucune source de données  |  Oui  |  Oui  | 
|  Amazon OpenSearch GET  |  Oui  |  Oui  | 
|  Amazon OpenSearch POST  |  Oui  |  Oui  | 
|  Amazon OpenSearch PUT  |  Oui  |  Oui  | 
|  Amazon OpenSearch SUPPRIMER  |  Oui  |  Oui  | 
|  Amazon OpenSearch GET  |  Oui  |  Oui  | 
|  DynamoDB GetItem  |  Oui  |  Oui  | 
|  DynamoDB Scan  |  Oui  |  Oui  | 
|  DynamoDB Query  |  Oui  |  Oui  | 
|  DynamoDB DeleteItem  |  Oui  |  Oui  | 
|  DynamoDB PutItem  |  Oui  |  Oui  | 
|  DynamoDB BatchGetItem  |  Non  |  Oui  | 
|  DynamoDB BatchPutItem  |  Non  |  Oui  | 
|  DynamoDB BatchDeleteItem  |  Non  |  Oui  | 
|  HTTP  |  Non  |  Oui  | 
|  Amazon RDS  |  Non  |  Oui  | 

 **Remarque** : Seule la version **2018-05-29** est actuellement prise en charge dans les fonctions.

## Modification de la version sur un modèle de mappage de résolveur d'unité
<a name="changing-the-version-on-a-unit-resolver-mapping-template"></a>

Pour les résolveurs d'unité, la version est spécifiée dans le corps du modèle de mappage de la requête. Pour mettre à jour la version, il vous suffit de mettre à jour le champ `version` avec la nouvelle version.

Par exemple, pour mettre à jour la version du AWS Lambda modèle :

```
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments": $utils.toJson($context.arguments)
    }
}
```

Vous devez mettre à jour le champ de version de `2017-02-28` en `2018-05-29` comme suit :

```
{
    "version": "2018-05-29", ## Note the version
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments": $utils.toJson($context.arguments)
    }
}
```

## Modification de la version sur une fonction
<a name="changing-the-version-on-a-function"></a>

Pour les fonctions, la version est spécifiée dans le champ `functionVersion` sur l'objet de la fonction. Pur mettre à jour la version, il vous suffit de mettre à jour `functionVersion`. *Remarque :* Actuellement, seul `2018-05-29` est pris en charge pour la fonction.

Voici un exemple de commande CLI pour mettre à jour la version d'une fonction existante :

```
aws appsync update-function \
--api-id REPLACE_WITH_API_ID \
--function-id REPLACE_WITH_FUNCTION_ID \
--data-source-name "PostTable" \
--function-version "2018-05-29" \
--request-mapping-template "{...}" \
--response-mapping-template "\$util.toJson(\$ctx.result)"
```

 **Remarque :** Il est recommandé d'omettre le champ de version dans le modèle de mappage de requête de la fonction car il ne sera pas respecté. Si vous spécifiez une version dans le modèle de mappage de requête d'une fonction, la valeur de la version sera remplacée par la valeur du champ `functionVersion`.

## 2018-05-29
<a name="aws-appsync-resolver-mapping-template-version-2018-05-29"></a>

### Changement de comportement
<a name="behavior-change"></a>
+ Si le résultat de l'appel de la source de données est `null`, le modèle de mappage de réponse est exécuté.
+ Si l'appel de la source de données génère une erreur, c'est à vous de la gérer, le résultat de l'évaluation du modèle de mappage de réponse sera **toujours** placé dans le bloc de réponse GraphQL`data`.

### Raisonnement
<a name="reasoning"></a>
+ Un résultat d'appel `null` a une signification, et dans certains cas d'utilisation d'application, il est possible que nous voulions gérer des résultats `null` de façon personnalisée. Par exemple, une application peut vérifier si un enregistrement existe dans une table Amazon DynamoDB pour réaliser un contrôle d'autorisation. Dans ce cas, un résultat d'appel `null` signifierait que l'utilisateur n'est probablement pas autorisé. L'exécution du modèle de mappage de réponse offre désormais la possibilité de générer une erreur de non autorisation. Ce comportement procure un meilleur contrôle au concepteur d'API.

Selon le modèle de mappage de réponse suivant :

```
$util.toJson($ctx.result)
```

Auparavant avec `2017-02-28`, si `$ctx.result` revenait nul, le modèle de mappage de réponse n'était pas exécuté. Avec `2018-05-29`, on peut désormais traiter ce scénario. Par exemple, on peut choisir de générer une erreur d'autorisation comme suit :

```
# throw an unauthorized error if the result is null
#if ( $util.isNull($ctx.result) )
    $util.unauthorized()
#end
$util.toJson($ctx.result)
```

 **Remarque :** Les erreurs provenant d'une source de données peuvent ne pas être fatales, voire attendues, c'est pourquoi le modèle de mappage de réponse devrait disposer de la possibilité de traiter l'erreur d'appel et de décider de l'ignorer, de la générer de nouveau ou de générer une autre erreur.

Selon le modèle de mappage de réponse suivant :

```
$util.toJson($ctx.result)
```

Auparavant, avec `2017-02-28`, en cas d'erreur d'appel, le modèle de mappage de réponse était évalué et le résultat était placé automatiquement dans le bloc `errors` de la réponse GraphQL. Avec `2018-05-29`, on peut désormais choisir que faire de l'erreur : la générer de nouveau, générer une erreur différente ou ajouter l'erreur tout en renvoyant des données.

### Générer de nouveau une erreur d'appel
<a name="re-raise-an-invocation-error"></a>

Dans le modèle de réponse suivant, on génère la même erreur que celle ayant été renvoyée à partir de la source de données.

```
#if ( $ctx.error )
    $util.error($ctx.error.message, $ctx.error.type)
#end
$util.toJson($ctx.result)
```

En cas d'erreur d'invocation (par exemple, présence de `$ctx.error`) la réponse ressemble à ceci :

```
{
    "data": {
        "getPost": null
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "DynamoDB:ConditionalCheckFailedException",
            "message": "Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

### Générer une autre erreur
<a name="raise-a-different-error"></a>

Dans le modèle de réponse suivant, on génère notre propre erreur personnalisée après avoir traité l'erreur renvoyée par la source de données.

```
#if ( $ctx.error )
    #if ( $ctx.error.type.equals("ConditionalCheckFailedException") )
        ## we choose here to change the type and message of the error for ConditionalCheckFailedExceptions
        $util.error("Error while updating the post, try again. Error: $ctx.error.message", "UpdateError")
    #else
        $util.error($ctx.error.message, $ctx.error.type)
    #end
#end
$util.toJson($ctx.result)
```

En cas d'erreur d'invocation (par exemple, présence de `$ctx.error`) la réponse ressemble à ceci :

```
{
    "data": {
        "getPost": null
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "UpdateError",
            "message": "Error while updating the post, try again. Error: Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

### Ajouter une erreur à des données renvoyées
<a name="append-an-error-to-return-data"></a>

Dans le modèle de réponse suivant, on ajoute la même erreur renvoyée depuis la source de données tout en renvoyant des données dans la réponse. Ce processus est également connu sous le nom de réponse partielle.

```
#if ( $ctx.error )
    $util.appendError($ctx.error.message, $ctx.error.type)
    #set($defaultPost = {id: "1", title: 'default post'})
    $util.toJson($defaultPost)
#else
    $util.toJson($ctx.result)
#end
```

En cas d'erreur d'invocation (par exemple, présence de `$ctx.error`) la réponse ressemble à ceci :

```
{
    "data": {
        "getPost": {
            "id": "1",
            "title: "A post"
        }
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "ConditionalCheckFailedException",
            "message": "Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

#### Migration de *2017-02-28* à *2018-05-29*
<a name="migrating-from-2017-02-28-to-2018-05-29"></a>

La migration de **2017-02-28** à **2018-05-29** est simple. Modifiez le champ de version sur le modèle de mappage de requête du résolveur ou sur l'objet de la version de la fonction. Cependant, notez que l'exécution de **2018-05-29** est différente de celle de **2017-02-28**. Les modifications sont décrites [ici](#aws-appsync-resolver-mapping-template-version-2018-05-29).

#### Préservation du même comportement d'exécution de *2017-02-28* à *2018-05-29*
<a name="preserving-the-same-execution-behavior-from-2017-02-28-to-2018-05-29"></a>

Dans certains cas, il est possible de conserver le même comportement d'exécution que celui de la version **2017-02-28** lorsqu'on exécute le modèle de version **2018-05-29**.

### Exemple : DynamoDB PutItem
<a name="example-dynamodb-putitem"></a>

Compte tenu du modèle de demande **DynamoDB 2017-02-28** suivant : PutItem

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    }
}
```

Et le modèle de réponse suivant :

```
$util.toJson($ctx.result)
```

La migration vers **2018-05-29** modifie ces modèles comme suit :

```
{
    "version" : "2018-05-29", ## Note the new 2018-05-29 version
    "operation" : "PutItem",
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    }
}
```

Et modifie le modèle de réponse de la façon suivante :

```
## If there is a datasource invocation error, we choose to raise the same error
## the field data will be set to null.
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
#end

## If the data source invocation is null, we return null.
#if($util.isNull($ctx.result))
  #return
#end

$util.toJson($ctx.result)
```

Il est désormais de votre responsabilité de gérer les erreurs. Nous avons choisi de générer la même erreur en utilisant `$util.error()`, ayant été renvoyé depuis DynamoDB. Vous pouvez adapter cet extrait pour convertir votre modèle de mappage en **2018-05-29**. Notez que si votre modèle de réponse est différent, vous devrez tenir compte des changements de comportement d'exécution.

### Exemple : DynamoDB GetItem
<a name="example-dynamodb-getitem"></a>

Compte tenu du modèle de demande **DynamoDB 2017-02-28** suivant : GetItem

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true
}
```

Et le modèle de réponse suivant :

```
## map table attribute postId to field Post.id
$util.qr($ctx.result.put("id", $ctx.result.get("postId")))

$util.toJson($ctx.result)
```

La migration vers **2018-05-29** modifie ces modèles comme suit :

```
{
    "version" : "2018-05-29", ## Note the new 2018-05-29 version
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true
}
```

Et modifie le modèle de réponse de la façon suivante :

```
## If there is a datasource invocation error, we choose to raise the same error
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type)
#end

## If the data source invocation is null, we return null.
#if($util.isNull($ctx.result))
  #return
#end

## map table attribute postId to field Post.id
$util.qr($ctx.result.put("id", $ctx.result.get("postId")))

$util.toJson($ctx.result)
```

Dans la version **2017-02-28**, si l'appel de source de données est `null`, ce qui signifie qu'aucun élément de la table DynamoDB ne correspond à notre clé, le modèle de mappage de réponse ne s'exécute pas. Cela ne pose aucun problème dans la plupart des cas, mais si vous attendiez que `$ctx.result` ne soit pas `null`, vous devez maintenant gérer ce scénario.

## 2017-02-28
<a name="aws-appsync-resolver-mapping-template-version-2017-02-28"></a>

### Caractéristiques
<a name="characteristics"></a>
+ Si le résultat de l'appel de source de données est `null` le modèle de mappage de réponse n'est **pas** exécuté.
+ Si l'appel de la source de données génère une erreur, le modèle de mappage de réponse est exécuté et le résultat évalué est placé dans le bloc `errors.data` de réponse GraphQL.