Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS AppSync JavaScript référence de fonction de résolution pour DynamoDB
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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-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/js-aws-appsync-resolver-reference-dynamodb-projections.html) - Découvrez comment spécifier des attributs dans les opérations de lecture.
# GetItem
La `GetItem` demande vous permet de demander à la fonction AWS AppSync DynamoDB d'envoyer `GetItem` une 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
La structure de la `GetItem` demande est la suivante :
```
type DynamoDBGetItem = {
operation: 'GetItem';
key: { [key: string]: any };
consistentRead?: ConsistentRead;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Les champs sont définis comme suit :
## GetItem champs
### GetItem liste des champs
**`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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-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 résultat du contexte (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Exemple
L'exemple suivant est un gestionnaire de demande de fonction pour une requête `getThing(foo: String!, bar: String!)` GraphQL :
```
export function request(ctx) {
const {foo, bar} = ctx.args
return {
operation : "GetItem",
key : util.dynamodb.toMapValues({foo, 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
Le document de mappage des demandes vous permet de `PutItem` demander à la fonction AWS AppSync DynamoDB d'envoyer `PutItem` une 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
La structure de la `PutItem` demande est la suivante :
```
type DynamoDBPutItemRequest = {
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: any};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Les champs sont définis comme suit :
## PutItem champs
### PutItem liste des champs
**`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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). 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 *guide 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 résultat du contexte (). `context.result`
L'élément écrit dans DynamoDB est automatiquement converti en types primitifs GraphQL et JSON et est disponible dans le résultat du contexte (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScriptrésolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Exemple 1
L'exemple suivant est un gestionnaire de demande de fonction pour une mutation `updateThing(foo: String!, bar: String!, name: String!, version: Int!)` GraphQL.
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é.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Exemple 2
L'exemple suivant est un gestionnaire de demande de fonction pour une mutation `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)` GraphQL.
Cet exemple vérifie que le champ de l'élément actuellement dans DynamoDB est `version` défini sur. `expectedVersion`
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, name, expectedVersion } = ctx.args;
const values = { name, version: expectedVersion + 1 };
let condition = util.transform.toDynamoDBConditionExpression({
version: { eq: expectedVersion },
});
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ foo, bar }),
attributeValues: util.dynamodb.toMapValues(values),
condition,
};
}
```
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
La `UpdateItem` demande vous permet de demander à la fonction 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
La structure de la `UpdateItem` demande est la suivante :
```
type DynamoDBUpdateItemRequest = {
operation: 'UpdateItem';
key: { [key: string]: any };
update: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Les champs sont définis comme suit :
## UpdateItem champs
### UpdateItem liste des champs
**`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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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 l'écriture d'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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). 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 *guide 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 résultat du contexte (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Exemple 1
L'exemple suivant est un gestionnaire de demande de fonction pour la mutation `upvote(id: ID!)` GraphQL.
Dans cet exemple, les champs et d'un élément de DynamoDB sont `upvotes` incrémentés de `version` 1.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id } = ctx.args;
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: 'ADD #votefield :plusOne, version :plusOne',
expressionNames: { '#votefield': 'upvotes' },
expressionValues: { ':plusOne': { N: 1 } },
},
};
}
```
## Exemple 2
L'exemple suivant est un gestionnaire de demande de fonction pour une mutation `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)` GraphQL.
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`
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { args: { input: { id, ...values } } } = ctx;
const condition = {
id: { attributeExists: true },
version: { eq: values.expectedVersion },
};
values.expectedVersion += 1;
return dynamodbUpdateRequest({ keys: { id }, values, condition });
}
/**
* Helper function to update an item
* @returns an UpdateItem request
*/
function dynamodbUpdateRequest(params) {
const { keys, values, condition: inCondObj } = params;
const sets = [];
const removes = [];
const expressionNames = {};
const expValues = {};
// Iterate through the keys of the values
for (const [key, value] of Object.entries(values)) {
expressionNames[`#${key}`] = key;
if (value) {
sets.push(`#${key} = :${key}`);
expValues[`:${key}`] = value;
} else {
removes.push(`#${key}`);
}
}
let expression = sets.length ? `SET ${sets.join(', ')}` : '';
expression += removes.length ? ` REMOVE ${removes.join(', ')}` : '';
const condition = JSON.parse(
util.transform.toDynamoDBConditionExpression(inCondObj)
);
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues(keys),
condition,
update: {
expression,
expressionNames,
expressionValues: util.dynamodb.toMapValues(expValues),
},
};
}
```
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
La `DeleteItem` demande vous permet de demander à la fonction 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
La structure de la `DeleteItem` demande est la suivante :
```
type DynamoDBDeleteItemRequest = {
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Les champs sont définis comme suit :
## DeleteItem champs
### DeleteItem liste des champs
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). 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 *guide 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 résultat du contexte (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Exemple 1
L'exemple suivant est un gestionnaire de demande de fonction pour une mutation `deleteItem(id: ID!)` GraphQL. S'il existe déjà un élément avec cet ID, il est supprimé.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
## Exemple 2
L'exemple suivant est un gestionnaire de demande de fonction pour une mutation `deleteItem(id: ID!, expectedVersion: Int!)` GraphQL. 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` :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, expectedVersion } = ctx.args;
const condition = {
id: { attributeExists: true },
version: { eq: expectedVersion },
};
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id }),
condition: util.transform.toDynamoDBConditionExpression(condition),
};
}
```
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
L'objet de `Query` requête vous permet de 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
La structure de l'objet de `Query` requête est la suivante :
```
type DynamoDBQueryRequest = {
operation: 'Query';
query: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
index?: string;
nextToken?: string;
limit?: number;
scanIndexForward?: boolean;
consistentRead?: boolean;
select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'SPECIFIC_ATTRIBUTES';
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Les champs sont définis comme suit :
## Champs de requête
### Liste des champs de requête
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). 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/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-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 résultat contextuel (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
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 entre différentes fonctions ou 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
L'exemple suivant est un gestionnaire de demande de fonction pour une requête `getPosts(owner: ID!)` GraphQL.
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é.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { owner } = ctx.args;
return {
operation: 'Query',
query: {
expression: 'ownerId = :ownerId',
expressionValues: util.dynamodb.toMapValues({ ':ownerId': 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
La `Scan` demande vous permet de demander à la fonction 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
La structure de l'objet de `Scan` requête est la suivante :
```
type DynamoDBScanRequest = {
operation: 'Scan';
index?: string;
limit?: number;
consistentRead?: boolean;
nextToken?: string;
totalSegments?: number;
segment?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Les champs sont définis comme suit :
## Numériser les champs
### Numériser la liste des champs
** `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)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). 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, la fonction 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/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-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 résultat contextuel (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
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. De plus, ces jetons de pagination ne peuvent pas être utilisés entre différentes fonctions ou 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
L'exemple suivant est un gestionnaire de demande de fonction pour la requête GraphQL :. `allPosts`
Dans cet exemple, toutes les entrées de la table sont renvoyées.
```
export function request(ctx) {
return { operation: 'Scan' };
}
```
## Exemple 2
L'exemple suivant est un gestionnaire de demande de fonction 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`.
```
export function request(ctx) {
const { title } = ctx.args;
const filter = { filter: { beginsWith: title } };
return {
operation: 'Scan',
filter: JSON.parse(util.transform.toDynamoDBFilterExpression(filter)),
};
}
```
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
L'objet de `Sync` requête 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
La structure de l'objet de `Sync` requête est la suivante :
```
type DynamoDBSyncRequest = {
operation: 'Sync';
basePartitionKey?: string;
deltaIndexName?: string;
limit?: number;
nextToken?: string;
lastSync?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
};
```
Les champs sont définis comme suit :
## Synchroniser les champs
### Liste des champs de synchronisation
** `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)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). 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 résultat contextuel (). `context.result`
Pour plus d'informations sur la conversion de type DynamoDB, [voir Système de types (](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses)mappage des réponses).
Pour plus d'informations sur les JavaScript résolveurs, consultez la section Présentation des [JavaScript résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
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. De plus, ces jetons de pagination ne peuvent pas être utilisés entre différentes fonctions ou 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
L'exemple suivant est un gestionnaire de demande de fonction 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.
```
export function request(ctx) {
const { nextToken, lastSync } = ctx.args;
return { operation: 'Sync', limit: 100, nextToken, lastSync };
}
```
# BatchGetItem
L'objet de `BatchGetItem` requête vous permet de demander à la fonction AWS AppSync DynamoDB d'envoyer une `BatchGetItem` demande à DynamoDB pour récupérer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de demande, vous devez spécifier les éléments suivants :
+ 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.
La structure de l'objet de `BatchGetItem` requête est la suivante :
```
type DynamoDBBatchGetItemRequest = {
operation: 'BatchGetItem';
tables: {
[tableName: string]: {
keys: { [key: string]: any }[];
consistentRead?: boolean;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
};
};
```
Les champs sont définis comme suit :
## BatchGetItem champs
### BatchGetItem liste des champs
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request)
** `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/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-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 l'objet de demande.
+ 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 gestionnaire de demandes de fonction suivant :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchGetItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
Le résultat de l'appel disponible dans `ctx.result` est le suivant :
```
{
"data": {
"authors": [null],
"posts": [
// Was retrieved
{
"authorId": "a1",
"postId": "p2",
"postTitle": "title",
"postDescription": "description",
}
]
},
"unprocessedKeys": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
`ctx.error` contient des détails sur l'erreur. La présence **des données** clés, **UnprocessedKeys**, et de chaque clé de table fournie dans le résultat de l'objet de demande de fonction est garantie 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**.
# BatchDeleteItem
L'objet de `BatchDeleteItem` requête vous permet de demander à la fonction AWS AppSync DynamoDB de `BatchWriteItem` demander à DynamoDB de supprimer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de demande, vous devez spécifier les éléments suivants :
+ 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.
La structure de l'objet de `BatchDeleteItem` requête est la suivante :
```
type DynamoDBBatchDeleteItemRequest = {
operation: 'BatchDeleteItem';
tables: {
[tableName: string]: { [key: string]: any }[];
};
};
```
Les champs sont définis comme suit :
## BatchDeleteItem champs
### BatchDeleteItem liste des champs
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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 l'objet de demande.
+ 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 gestionnaire de demandes de fonction suivant :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchDeleteItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
Le résultat de l'appel disponible dans `ctx.result` est le suivant :
```
{
"data": {
"authors": [null],
"posts": [
// Was deleted
{
"authorId": "a1",
"postId": "p2"
}
]
},
"unprocessedKeys": {
"authors": [
// This key was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
`ctx.error` contient des détails sur l'erreur. La présence **des données** clés, **UnprocessedKeys**, et de chaque clé de table fournie dans l'objet de demande de fonction est garantie 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**.
# BatchPutItem
L'objet de `BatchPutItem` requête vous permet de demander à la fonction AWS AppSync DynamoDB d'envoyer une `BatchWriteItem` demande à DynamoDB pour placer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de demande, vous devez spécifier les éléments suivants :
+ 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.
La structure de l'objet de `BatchPutItem` requête est la suivante :
```
type DynamoDBBatchPutItemRequest = {
operation: 'BatchPutItem';
tables: {
[tableName: string]: { [key: string]: any}[];
};
};
```
Les champs sont définis comme suit :
## BatchPutItem champs
### BatchPutItem liste des champs
** `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 l'objet de demande.
+ 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 gestionnaire de demandes de fonction suivant :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, name, title } = ctx.args;
return {
operation: 'BatchPutItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId, name })],
posts: [util.dynamodb.toMapValues({ authorId, postId, title })],
},
};
}
```
Le résultat de l'appel disponible dans `ctx.result` est le suivant :
```
{
"data": {
"authors": [
null
],
"posts": [
// Was inserted
{
"authorId": "a1",
"postId": "p2",
"title": "title"
}
]
},
"unprocessedItems": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1",
"name": "a1_name"
}
],
"posts": []
}
}
```
`ctx.error` contient des détails sur l'erreur. La présence **des données** clés, **UnprocessedItems** et de chaque clé de table fournie dans l'objet de demande est garantie 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**.
# TransactGetItems
L'objet de `TransactGetItems` requête vous permet de demander à la fonction AWS AppSync DynamoDB d'envoyer une `TransactGetItems` demande à DynamoDB pour récupérer plusieurs éléments, éventuellement sur plusieurs tables. Pour cet objet de demande, vous devez spécifier les éléments suivants :
+ 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.
La structure de l'objet de `TransactGetItems` requête est la suivante :
```
type DynamoDBTransactGetItemsRequest = {
operation: 'TransactGetItems';
transactItems: { table: string; key: { [key: string]: any }; projection?: { expression: string; expressionNames?: { [key: string]: string }; }[];
};
};
```
Les champs sont définis comme suit :
## TransactGetItems champs
### TransactGetItems liste des champs
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request)
**`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/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-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 gestionnaire de demandes de fonction suivant :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'TransactGetItems',
transactItems: [
{
table: 'posts',
key: util.dynamodb.toMapValues({ postId }),
},
{
table: 'authors',
key: util.dynamodb.toMapValues({ authorId }),
},
],
};
}
```
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`.
# TransactWriteItems
L'objet de `TransactWriteItems` requête vous permet de demander à la fonction AWS AppSync DynamoDB de `TransactWriteItems` demander à DynamoDB d'écrire plusieurs éléments, éventuellement dans plusieurs tables. Pour cet objet de demande, vous devez spécifier les éléments suivants :
+ 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.
La structure de l'objet de `TransactWriteItems` requête est la suivante :
```
type DynamoDBTransactWriteItemsRequest = {
operation: 'TransactWriteItems';
transactItems: TransactItem[];
};
type TransactItem =
| TransactWritePutItem
| TransactWriteUpdateItem
| TransactWriteDeleteItem
| TransactWriteConditionCheckItem;
type TransactWritePutItem = {
table: string;
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: string};
condition?: TransactConditionCheckExpression;
};
type TransactWriteUpdateItem = {
table: string;
operation: 'UpdateItem';
key: { [key: string]: any };
update: DynamoDBExpression;
condition?: TransactConditionCheckExpression;
};
type TransactWriteDeleteItem = {
table: string;
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactWriteConditionCheckItem = {
table: string;
operation: 'ConditionCheck';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
returnValuesOnConditionCheckFailure: boolean;
};
```
## TransactWriteItems champs
### TransactWriteItems liste des champs
**Les champs sont définis comme suit : **
** `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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). 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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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 l'écriture d'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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). 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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). 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 dont l'état doit être vérifié. 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).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). 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. Dans le cas contraire, ils provoqueront *TransactionCanceledException*une 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 gestionnaire de demandes de fonction suivant :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, title, description, oldTitle, authorName } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'PutItem',
key: util.dynamodb.toMapValues({ postId }),
attributeValues: util.dynamodb.toMapValues({ title, description }),
condition: util.transform.toDynamoDBConditionExpression({
title: { eq: oldTitle },
}),
},
{
table: 'authors',
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ authorId }),
update: {
expression: 'SET authorName = :name',
expressionValues: util.dynamodb.toMapValues({ ':name': authorName }),
},
},
],
};
}
```
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`.
# Système de types (mappage des demandes)
Lorsque vous utilisez la fonction 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, l'objet de la requête n'est pas analysé.
Une valeur DynamoDB est utilisée n'importe où dans un objet de requête 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 objet de requête).
```
"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)
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 du gestionnaire de réponses.
Par exemple, si DynamoDB renvoie ce qui suit :
```
{
"id" : { "S" : "1234" },
"name" : { "S" : "Nadia" },
"age" : { "N" : 25 }
}
```
Lorsque le résultat est renvoyé par votre résolveur de pipeline, il le AWS AppSync convertit 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 de caractères :
```
"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 forme de 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 toutes les autres valeurs DynamoDB prises 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
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 propriété de filtre d'une `Scan` demande `Query` ou possède la structure suivante :
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
};
```
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 plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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
L'exemple suivant est une section de filtre pour une demande, dans laquelle les entrées extraites de DynamoDB ne sont renvoyées que si le titre commence par l'argument. `title`
Ici, nous utilisons le `util.transform.toDynamoDBFilterExpression` pour créer automatiquement un filtre à partir d'un objet :
```
const filter = util.transform.toDynamoDBFilterExpression({
title: { beginsWith: 'far away' },
});
const request = {};
request.filter = JSON.parse(filter);
```
Cela génère le filtre suivant :
```
{
"filter": {
"expression": "(begins_with(#title,:title_beginsWith))",
"expressionNames": { "#title": "title" },
"expressionValues": {
":title_beginsWith": { "S": "far away" }
}
}
}
```
# Expressions conditionnelles
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.
La fonction AWS AppSync DynamoDB permet de spécifier une expression de condition `PutItem` dans`UpdateItem`, `DeleteItem` et des objets de demande, ainsi qu'une stratégie à suivre si la condition échoue et que l'objet n'a pas été mis à jour.
## Exemple 1
L'objet de `PutItem` demande suivant ne possède pas d'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.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Exemple 2
L'`PutItem`objet suivant possède 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.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
condition: { expression: "attribute_not_exists(id)" }
};
}
```
Par défaut, si le contrôle de condition échoue, la fonction AWS AppSync DynamoDB génère une erreur pour la mutation.
Cependant, la fonction AWS AppSync DynamoDB propose des fonctionnalités supplémentaires pour aider les développeurs à gérer certains cas extrêmes courants :
+ Si les fonctions AWS AppSync DynamoDB peuvent déterminer que la valeur actuelle dans DynamoDB correspond au résultat souhaité, elles traitent l'opération comme si elle avait réussi de toute façon.
+ Au lieu de renvoyer une erreur, vous pouvez configurer la fonction pour appeler une fonction Lambda personnalisée afin de décider comment la fonction DynamoDB doit AWS AppSync gérer l'échec.
Ils sont décrits plus en détail dans la section [Gestion d'un échec de vérification d'état](#condition-check).
[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
Les objets `PutItem``UpdateItem`,, et `DeleteItem` request permettent tous de spécifier une `condition` section 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 :
```
type ConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
equalsIgnore?: string[];
consistentRead?: boolean;
conditionalCheckFailedHandler?: {
strategy: 'Custom' | 'Reject';
lambdaArn?: string;
};
};
```
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 plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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 à la fonction 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, la fonction AWS AppSync DynamoDB compare l'élément actuellement dans DynamoDB à l'élément qu'elle 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 à la fonction 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 la fonction 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 la fonction 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` **
La fonction AWS AppSync DynamoDB invoque une fonction Lambda personnalisée pour décider comment 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 la fonction 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 fonctionnalité, consultez la section [Gestion d'un échec de vérification d'état](#condition-check).
## Gestion d'un échec de vérification d'état
Lorsqu'une vérification de condition échoue, la fonction AWS AppSync DynamoDB peut transmettre l'erreur liée à la mutation et la valeur actuelle de l'objet à l'aide de l'utilitaire. `util.appendError` Cependant, la fonction AWS AppSync DynamoDB propose des fonctionnalités supplémentaires pour aider les développeurs à gérer certains cas extrêmes courants :
+ Si les fonctions AWS AppSync DynamoDB peuvent déterminer que la valeur actuelle dans DynamoDB correspond au résultat souhaité, elles traitent l'opération comme si elle avait réussi de toute façon.
+ Au lieu de renvoyer une erreur, vous pouvez configurer la fonction pour appeler une fonction Lambda personnalisée afin de décider comment la fonction DynamoDB doit AWS AppSync gérer l'échec.
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é
Lorsque le contrôle de condition échoue, la fonction AWS AppSync DynamoDB exécute une requête `GetItem` 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, la fonction AWS AppSync DynamoDB compare la valeur actuelle à celle qu'elle a tenté d'écrire, en excluant les attributs répertoriés `equalsIgnore` dans 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 l'objet de la `PutItem` requête ressemblait à ce qui suit :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, name, version} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues({ name, version: version+1 }),
condition: {
expression: "version = :expectedVersion",
expressionValues: util.dynamodb.toMapValues({':expectedVersion': version}),
equalsIgnore: ['version']
}
};
}
```
Et si l'élément actuellement dans DynamoDB ressemble à ce qui suit :
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
La fonction AWS AppSync DynamoDB comparait l'élément qu'elle a essayé d'écrire à la valeur actuelle, constatait que la seule différence était `version` le champ, mais comme elle est configurée pour ignorer `version` le champ, elle considère l'opération comme réussie et renvoie l'élément extrait de DynamoDB.
+ Pour l'`DeleteItem`opération, la fonction 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, la fonction 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, la fonction 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 »
Lorsque vous suivez la `Reject` stratégie, la fonction 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 le gestionnaire de réponse aux fonctions ressemble à ce qui suit :
```
import { util } from '@aws-appsync/utils';
export function response(ctx) {
const { version, ...values } = ctx.result;
const result = { ...values, theVersion: version };
if (ctx.error) {
if (error) {
return util.appendError(error.message, error.type, result, null);
}
}
return result
}
```
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 »
Lorsque vous suivez la `Custom` stratégie, la fonction 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 à la fonction 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 à la fonction 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 à la fonction AWS AppSync DynamoDB de réessayer la mutation avec un nouvel objet de requête.
**Requête d'appel Lambda**
La fonction AWS AppSync DynamoDB appelle 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. Il s'agit des mêmes arguments que les arguments disponibles pour l'objet de requête dans`context.arguments`.
** `requestMapping` **
L'objet de la demande pour cette opération.
** `currentValue` **
La valeur actuelle de l'objet dans DynamoDB.
** `resolver` **
Informations sur le AWS AppSync résolveur ou la fonction.
** `identity` **
Informations sur l'appelant. Il s'agit de la même chose que les informations d'identité disponibles pour l'objet de la demande 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 la fonction 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 à la fonction 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 à la fonction 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 à la fonction AWS AppSync DynamoDB de réessayer la mutation avec un nouvel objet de requête. La structure de la `retryMapping` section dépend de l'opération DynamoDB et constitue un sous-ensemble de l'objet de demande complet pour cette opération.
Pour `PutItem`, la section `retryMapping` a la structure suivante. Pour une description du `attributeValues` champ, voir [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-putitem).
```
{
"attributeValues": { ... },
"condition": {
"equalsIgnore" = [ ... ],
"consistentRead" = true
}
}
```
Pour `UpdateItem`, la section `retryMapping` a la structure suivante. Pour une description de `update` cette section, voir [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem).
```
{
"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. La fonction 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, la fonction 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
Les expressions de conditions de transaction sont disponibles dans les demandes 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
Le gestionnaire de demande de `DeleteItem` fonction transactionnelle suivant ne possède pas d'expression de condition. Par conséquent, il supprime l'élément dans DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
}
],
};
}
```
## Exemple 2
Le gestionnaire de demande de `DeleteItem` fonction transactionnelle suivant possède 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.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId, authorName} = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
condition: util.transform.toDynamoDBConditionExpression({
authorName: { eq: authorName },
}),
}
],
};
}
```
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
Les objets `PutItem``UpdateItem`,, et `DeleteItem` request permettent tous de spécifier une `condition` section 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 :
```
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: string };
returnValuesOnConditionCheckFailure: boolean;
};
```
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 plus d'informations sur la façon de spécifier une « valeur saisie », voir [Système de types (mappage des demandes).](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request) 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[].item`, où `` 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
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 propriété de projection est la suivante, similaire à celle des filtres :
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string}
};
```
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 des 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
L'exemple suivant est une section de projection pour une JavaScript fonction dans laquelle 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. [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js) 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).