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 fonctionnalités d'exécution pour les résolveurs et les fonctions L'environnement `APPSYNC_JS` d'exécution fournit des fonctionnalités similaires à la [version 6.0 ECMAScript (ES)](https://262.ecma-international.org/6.0/). Il prend en charge un sous-ensemble de ses fonctionnalités et fournit des méthodes supplémentaires (utilitaires) qui ne font pas partie des spécifications ES. Les rubriques suivantes répertorient toutes les fonctionnalités linguistiques prises en charge : + [Fonctionnalités d'exécution prises](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html) en charge - En savoir plus sur les fonctionnalités de base prises en charge, les objets primitifs, les objets et fonctions intégrés, etc. + [Utilitaires intégrés](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) - La variable util contient des méthodes utilitaires générales pour vous aider à travailler avec les données. Sauf indication contraire, tous les utilitaires emploient le jeu de caractères UTF-8. + [Modules intégrés](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) - Découvrez comment les modules intégrés peuvent aider à écrire des JavaScript résolveurs et des fonctions. + [Utilitaires](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html) d'exécution - La bibliothèque d'exécution fournit des utilitaires permettant de contrôler ou de modifier les propriétés d'exécution de vos résolveurs et fonctions. + [Assistants temporels dans util.time - La variable util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) contient des méthodes datetime permettant de générer des horodatages, de convertir des formats de date/heure et d'analyser des chaînes de date/heure. La syntaxe des formats datetime est basée sur celle-ci [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), à laquelle vous pouvez vous référer pour de plus amples informations. + [Les aides DynamoDB dans util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) - util.dynamodb contient des méthodes d'assistance qui facilitent l'écriture et la lecture de données sur Amazon DynamoDB, telles que le mappage automatique des types et le formatage. + [Helpers HTTP dans util.http - L'utilitaire util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) fournit des méthodes d'assistance que vous pouvez utiliser pour gérer les paramètres des requêtes HTTP et pour ajouter des en-têtes de réponse. + [Assistants à la transformation dans util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) - util.transform contient des méthodes d'assistance qui facilitent l'exécution d'opérations complexes sur des sources de données. + [Les assistants de chaîne dans util.str - util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) contiennent des méthodes pour faciliter les opérations courantes sur les chaînes de caractères. + [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) : les extensions contiennent un ensemble de méthodes permettant d'effectuer des actions supplémentaires dans vos résolveurs. + [Les aides XML du fichier util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml contiennent des méthodes pour faciliter la conversion de chaînes XML. **Note** Actuellement, cette référence ne s'applique qu'à la version d'exécution **1.0.0**. # Fonctionnalités d'exécution prises en charge Les sections ci-dessous décrivent l'ensemble des fonctionnalités prises en charge par le moteur d'exécution APPSYNC\$1JS. ## Fonctions de base Les fonctionnalités principales suivantes sont prises en charge. ------ #### [ Types ] Les types suivants sont pris en charge : + nombres + chaînes + booléens + objects + tableaux + functions ------ #### [ Operators ] Les opérateurs sont pris en charge, notamment : + opérateurs mathématiques standard (`+`, `-``/`,`%`,`*`,, etc.) + opérateur de coalescence nul () `??` + Chainage optionnel () `?.` + opérateurs bit à bit + `void`et `typeof` opérateurs + opérateurs de propagation (`...`) Les opérateurs suivants ne sont pas pris en charge : + opérateurs unaires (`++`,`--`, et`~`) + Opérateur `in` **Note** Utilisez l'`Object.hasOwn`opérateur pour vérifier si la propriété spécifiée se trouve dans l'objet spécifié. ------ #### [ Statements ] Les déclarations suivantes sont prises en charge : + `const` + `let` + `var` + `break` + `else` + `for-in` + `for-of` + `if` + `return` + `switch` + syntaxe de propagation Les éléments suivants ne sont pas pris en charge : + `catch` + `continue` + `do-while` + `finally` + `for(initialization; condition; afterthought)` **Note** Les exceptions sont les `for-of` expressions `for-in` et les expressions, qui sont prises en charge. + `throw` + `try` + `while` + déclarations étiquetées ------ #### [ Literals ] Les [littéraux de modèle](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES 6 suivants sont pris en charge : + Cordes multilignes + Interpolation d'expressions + Modèles d'imbrication ------ #### [ Functions ] La syntaxe de fonction suivante est prise en charge : + Les déclarations de fonctions sont prises en charge. + Les fonctions de flèche ES 6 sont prises en charge. + La syntaxe des paramètres de repos ES 6 est prise en charge. ------ #### [ Strict mode ] Les fonctions opèrent en mode strict par défaut. Vous n’avez donc pas besoin d’ajouter une instruction `use_strict` dans votre code de fonction. Elles ne peuvent pas être modifiées. ------ ## Objets primitifs Les objets primitifs suivants d'ES et leurs fonctions sont pris en charge. ------ #### [ Object ] Les objets suivants sont pris en charge : + `Object.assign()` + `Object.entries()` + `Object.hasOwn()` + `Object.keys()` + `Object.values()` + `delete` ------ #### [ String ] Les chaînes suivantes sont prises en charge : + `String.prototype.length()` + `String.prototype.charAt()` + `String.prototype.concat()` + `String.prototype.endsWith()` + `String.prototype.indexOf()` + `String.prototype.lastIndexOf()` + `String.raw()` + `String.prototype.replace()` **Note** Les expressions régulières ne sont pas prises en charge. Cependant, les constructions d'expressions régulières de style Java sont prises en charge dans le paramètre fourni. Pour plus d'informations, voir [Motif](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html). + `String.prototype.replaceAll()` **Note** Les expressions régulières ne sont pas prises en charge. Cependant, les constructions d'expressions régulières de style Java sont prises en charge dans le paramètre fourni. Pour plus d'informations, voir [Motif](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html). + `String.prototype.slice()` + `String.prototype.split()` + `String.prototype.startsWith()` + `String.prototype.toLowerCase()` + `String.prototype.toUpperCase()` + `String.prototype.trim()` + `String.prototype.trimEnd()` + `String.prototype.trimStart()` ------ #### [ Number ] Les numéros suivants sont pris en charge : + `Number.isFinite` + `Number.isNaN` ------ ## Objets et fonctions intégrés Les fonctions et objets suivants sont pris en charge. ------ #### [ Math ] Les fonctions mathématiques suivantes sont prises en charge : + `Math.random()` + `Math.min()` + `Math.max()` + `Math.round()` + `Math.floor()` + `Math.ceil()` ------ #### [ Array ] Les méthodes matricielles suivantes sont prises en charge : + `Array.prototype.length` + `Array.prototype.concat()` + `Array.prototype.fill()` + `Array.prototype.flat()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.sort()` **Note** `Array.prototype.sort()`ne supporte pas les arguments. + `Array.prototype.splice()` + `Array.prototype.unshift()` + `Array.prototype.forEach()` + `Array.prototype.map()` + `Array.prototype.flatMap()` + `Array.prototype.filter()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.find()` + `Array.prototype.some()` + `Array.prototype.every()` + `Array.prototype.findIndex()` + `Array.prototype.findLast()` + `Array.prototype.findLastIndex()` + `delete` ------ #### [ Console ] L'objet console est disponible pour le débogage. Pendant l'exécution des requêtes en direct, les log/error instructions de console sont envoyées à Amazon CloudWatch Logs (si la journalisation est activée). Lors de l'évaluation du code avec`evaluateCode`, les instructions de journal sont renvoyées dans la réponse à la commande. + `console.error()` + `console.log()` ------ #### [ Function ] + Les `call` méthodes `apply``bind`, et ne sont pas prises en charge. + Les constructeurs de fonctions ne sont pas pris en charge. + La transmission d'une fonction en tant qu'argument n'est pas prise en charge. + Les appels de fonction récursifs ne sont pas pris en charge. ------ #### [ JSON ] Les méthodes JSON suivantes sont prises en charge : + `JSON.parse()` **Note** Renvoie une chaîne vide si la chaîne analysée n'est pas un JSON valide. + `JSON.stringify()` ------ #### [ Promises ] Les processus asynchrones ne sont pas pris en charge et les promesses ne sont pas prises en charge. **Note** L'accès au réseau et au système de fichiers n'est pas pris en charge au cours de l'`APPSYNC_JS`exécution dans AWS AppSync. AWS AppSync gère toutes les opérations d'E/S en fonction des demandes faites par le AWS AppSync résolveur ou AWS AppSync la fonction. ------ ## Globals Les constantes globales suivantes sont prises en charge : + `NaN` + `Infinity` + `undefined` + [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) + [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) + `runtime` ## Types d’erreurs Le renvoi d'erreurs avec n'`throw`est pas pris en charge. Vous pouvez renvoyer une erreur en utilisant `util.error()` la fonction. Vous pouvez inclure une erreur dans votre réponse GraphQL en utilisant la `util.appendError` fonction. Pour plus d'informations, consultez la section [Utils d'erreur](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js). # Utilitaires intégrés La `util` variable contient des méthodes utilitaires générales pour vous aider à travailler avec les données. Sauf indication contraire, tous les utilitaires emploient le jeu de caractères UTF-8. ## Utilitaires d'encodage ### Liste des utilitaires d'encodage **`util.urlEncode(String)`** Renvoie la chaîne en entrée sous la forme d'une chaîne codée `application/x-www-form-urlencoded`. **`util.urlDecode(String)`** Décode une chaîne codée `application/x-www-form-urlencoded` sous sa forme initiale non codée. **`util.base64Encode(string) : string`** Code les données d'entrée en une chaîne codée en base64. **`util.base64Decode(string) : string`** Décode les données d’une chaîne encodée en base64. ## Utilitaires de génération d'identifiants ### Liste des utilitaires de génération d'identifiants **`util.autoId()`** Renvoie un UUID 128 bits généré de façon aléatoire. **`util.autoUlid()`** Renvoie un ULID (identifiant lexicographiquement sortable universel unique) de 128 bits généré aléatoirement. **`util.autoKsuid()`** Renvoie un KSUID (K-Sortable Unique Identifier) de 128 bits généré aléatoirement en base62 et codé sous forme de chaîne d'une longueur de 27. ## Utils d'erreur ### Liste des utilitaires d'erreur **`util.error(String, String?, Object?, Object?)`** Lève une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, un `errorType` champ, un `data` champ et un `errorInfo` champ peuvent être spécifiés. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. `data`sera filtré en fonction de l'ensemble de sélection de requêtes. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. `errorInfo`**ne sera pas** filtré en fonction de l'ensemble de sélection de requêtes. **`util.appendError(String, String?, Object?, Object?)`** Ajoute une erreur personnalisée. Peut être utilisé dans les modèles de mappage de demande ou de réponse si le modèle détecte une erreur associée à la demande ou au résultat de l'appel. En outre, un `errorType` champ, un `data` champ et un `errorInfo` champ peuvent être spécifiés. Contrairement à `util.error(String, String?, Object?, Object?)`, l'évaluation du modèle n'est pas interrompue et, par conséquent, les données peuvent être retournées à l'appelant. La valeur `data` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. `data`sera filtré en fonction de l'ensemble de sélection de requêtes. La valeur `errorInfo` sera ajoutée au bloc `error` correspondant à l'intérieur d'`errors` dans la réponse GraphQL. `errorInfo`**ne sera pas** filtré en fonction de l'ensemble de sélection de requêtes. ## Utilitaires de correspondance de types et de modèles ### Liste d'utilitaires correspondant au type et au modèle **`util.matches(String, String) : Boolean`** Renvoie la valeur true si le modèle spécifié dans le premier argument correspond aux données fournies dans le deuxième argument. Le modèle doit être une expression régulière, telle que `util.matches("a*b", "aaaaab")`. La fonctionnalité est basée sur [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), que vous pouvez référencer à titre de documentation ultérieure. **`util.authType()`** Renvoie une chaîne décrivant le type d'authentification multiple utilisé par une demande, renvoyant soit « IAM Authorization », « User Pool Authorization », « Open ID Connect Authorization », soit « API Key Authorization ». ## Utilitaires de comportement des valeurs renvoyées ### Liste des utilitaires relatifs au comportement des valeurs renvoyées **`util.escapeJavaScript(String)`** Renvoie la chaîne d'entrée sous forme de chaîne JavaScript échappée. ## Utilitaires d'autorisation du résolveur ### Liste des utilitaires d'autorisation du résolveur **`util.unauthorized()`** Lève `Unauthorized` pour le champ en cours de résolution. Utilisez-le dans les modèles de mappage de demandes ou de réponses pour déterminer s'il convient d'autoriser l'appelant à résoudre le champ. # Modules intégrés Les modules font partie de l'`APPSYNC_JS`environnement d'exécution et fournissent des utilitaires pour aider à écrire des JavaScript résolveurs et des fonctions. Pour des exemples et des exemples, consultez le [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub référentiel. ## Fonctions du module DynamoDB Les fonctions du module DynamoDB offrent une expérience améliorée lors de l'interaction avec les sources de données DynamoDB. Vous pouvez envoyer des requêtes à vos sources de données DynamoDB à l'aide des fonctions et sans ajouter de mappage de type. Les modules sont importés à l'aide de `@aws-appsync/utils/dynamodb` : ``` // Modules are imported using @aws-appsync/utils/dynamodb import * as ddb from '@aws-appsync/utils/dynamodb'; ``` ### Fonctions #### Liste des fonctions **` get(payload: GetInput): DynamoDBGetItemRequest`** Voir [Inputs](#built-in-ddb-modules-inputs) pour plus d'informations sur GetInput. Génère un `DynamoDBGetItemRequest` objet pour envoyer une [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)requête à DynamoDB. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Génère un `DynamoDBPutItemRequest` objet pour envoyer une [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)requête à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb' export function request(ctx) { return ddb.put({ key: { id: util.autoId() }, item: ctx.args }); } ``` **`remove(payload): DynamoDBDeleteItemRequest`** Génère un `DynamoDBDeleteItemRequest` objet pour envoyer une [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)requête à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return ddb.remove({ key: { id: ctx.args.id } }); } ``` **`scan(payload): DynamoDBScanRequest`** Génère un `DynamoDBScanRequest` pour envoyer une demande de [scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) à DynamoDB. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken } = ctx.args; return ddb.scan({ limit, nextToken }); } ``` **`sync(payload): DynamoDBSyncRequest`** Génère un `DynamoDBSyncRequest` objet pour effectuer une demande de [synchronisation](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). La demande ne reçoit que les données modifiées depuis la dernière requête (mises à jour delta). Les demandes peuvent uniquement être adressées à des sources de données DynamoDB versionnées. ``` import * as ddb from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const { limit = 10, nextToken, lastSync } = ctx.args; return ddb.sync({ limit, nextToken, lastSync }); } ``` **`update(payload): DynamoDBUpdateItemRequest`** Génère un `DynamoDBUpdateItemRequest` objet pour envoyer une [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)requête à DynamoDB. ### Opérations Les aides aux opérations vous permettent d'effectuer des actions spécifiques sur certaines parties de vos données lors des mises à jour. Pour commencer, importez `operations` depuis `@aws-appsync/utils/dynamodb` : ``` // Modules are imported using operations import {operations} from '@aws-appsync/utils/dynamodb'; ``` #### Liste des opérations **`add(payload)`** Fonction d'assistance qui ajoute un nouvel élément d'attribut lors de la mise à jour de DynamoDB. **Exemple** Pour ajouter une adresse (rue, ville et code postal) à un élément DynamoDB existant à l'aide de la valeur ID : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { address: operations.add({ street1: '123 Main St', city: 'New York', zip: '10001', }), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`append (payload)`** Fonction d'assistance qui ajoute une charge utile à la liste existante dans DynamoDB. **Exemple** Pour ajouter un ami IDs (`newFriendIds`) récemment ajouté à une liste d'amis existante (`friendsIds`) lors d'une mise à jour : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.append(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`decrement (by?)`** Fonction d'assistance qui décrémente la valeur d'attribut existante dans l'élément lors de la mise à jour de DynamoDB. **Exemple** Pour réduire le compteur (`friendsCount`) d'un ami de 10 : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.decrement(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`increment (by?)`** Fonction d'assistance qui incrémente la valeur d'attribut existante dans l'élément lors de la mise à jour de DynamoDB. **Exemple** Pour augmenter de 10 le compteur d'amis (`friendsCount`) : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { friendsCount: operations.increment(10), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`prepend (payload)`** Fonction d'assistance qui ajoute un préfixe à la liste existante dans DynamoDB. **Exemple** Pour ajouter un nouvel ami IDs (`newFriendIds`) à une liste d'amis existante (`friendsIds`) lors d'une mise à jour : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [101, 104, 111]; const updateObj = { friendsIds: operations.prepend(newFriendIds), }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`replace (payload)`** Fonction d'assistance qui remplace un attribut existant lors de la mise à jour d'un élément dans DynamoDB. Cela est utile lorsque vous souhaitez mettre à jour l'intégralité de l'objet ou du sous-objet de l'attribut et pas uniquement les clés de la charge utile. **Exemple** Pour remplacer une adresse (rue, ville et code postal) dans un `info` objet : ``` import { update, operations } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const updateObj = { info: { address: operations.replace({ street1: '123 Main St', city: 'New York', zip: '10001', }), }, }; return update({ key: { id: 1 }, update: updateObj }); } ``` **`updateListItem (payload, index)`** Fonction d'assistance qui remplace un élément d'une liste. **Exemple** Dans le cadre de la mise à jour (`newFriendIds`), cet exemple a `updateListItem` été utilisé pour mettre à jour les valeurs d'ID du deuxième élément (index :`1`, new ID :`102`) et du troisième élément (index :`2`, new ID :`112`) dans une liste (`friendsIds`). ``` import { update, operations as ops } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { const newFriendIds = [ ops.updateListItem('102', 1), ops.updateListItem('112', 2) ]; const updateObj = { friendsIds: newFriendIds }; return update({ key: { id: 1 }, update: updateObj }); } ``` ### Inputs #### Liste des entrées **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Déclaration de type** + `consistentRead?: boolean` (facultatif) Un booléen facultatif qui indique si vous souhaitez effectuer une lecture très cohérente avec DynamoDB. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. **`Type PutInput`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject | null` (facultatif) Lorsque vous placez un objet dans une table DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle 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. + `customPartitionKey?: string` (facultatif) 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 versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `item: Partial` (obligatoire) Le reste des attributs de l'élément à placer dans DynamoDB. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément dans DynamoDB sur lequel le placement sera effectué. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. + `populateIndexFields?: boolean` (facultatif) 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*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Déclaration de type** + `query: DynamoDBKeyCondition>` (obligatoire) Spécifie une condition clé qui décrit les éléments à interroger. Pour un index donné, la condition d'une clé de partition doit être une égalité et la clé de tri une comparaison ou un `beginsWith` (lorsqu'il s'agit d'une chaîne). Seuls les types de nombres et de chaînes sont pris en charge pour les clés de partition et de tri. **Exemple** Prenez le `User` type ci-dessous : ``` type User = { id: string; name: string; age: number; isVerified: boolean; friendsIds: string[] } ``` La requête ne peut inclure que les champs suivants : `id``name`, et `age` : ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject` (facultatif) Lorsque vous supprimez un objet dans DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle 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. **Exemple** L'exemple suivant est une `DeleteItem` expression contenant une condition qui permet à l'opération de réussir uniquement si le propriétaire du document correspond à l'utilisateur qui fait la demande. ``` type Task = { id: string; title: string; description: string; owner: string; isComplete: boolean; } const condition: DynamoDBFilterObject = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (facultatif) Lorsqu'elle est activée, la `customPartitionKey` valeur modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément en cours de suppression dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. **Exemple** Si a `User` uniquement la clé de hachage d'un utilisateur`id`, la clé ressemblera à ceci : ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { id: 1, } ``` Si l'utilisateur de la table possède une clé de hachage (`id`) et une clé de tri (`name`), la clé ressemblera à ceci : ``` type User = { id: number name: string age: number isVerified: boolean friendsIds: string[] } const key: DynamoDBKey = { id: 1, name: 'XXXXXXXXXX', } ``` + `populateIndexFields?: boolean` (facultatif) 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`. **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | null; index?: string | null; limit?: number | null; nextToken?: string | null; scanIndexForward?: boolean | null; segment?: number; select?: DynamoDBSelectAttributes; totalSegments?: number; } ``` **Déclaration de type** + `consistentRead?: boolean | null` (facultatif) Un booléen facultatif pour indiquer des lectures cohérentes lors de l'interrogation de DynamoDB. La valeur par défaut est `false`. + `filter?: DynamoDBFilterObject | null` (facultatif) Filtre facultatif à appliquer aux résultats après les avoir extraits du tableau. + `index?: string | null` (facultatif) Nom facultatif de l'index à analyser. + `limit?: number | null` (facultatif) Nombre maximal facultatif de résultats à renvoyer. + `nextToken?: string | null` (facultatif) Un jeton de pagination facultatif pour poursuivre une requête précédente. Il a été obtenu à partir d'une requête précédente. + `scanIndexForward?: boolean | null` (facultatif) Un booléen facultatif indiquant si la requête est exécutée par ordre croissant ou décroissant. Par défaut, cette valeur indique `true`. + `segment?: number` (facultatif) + `select?: DynamoDBSelectAttributes` (facultatif) Attributs à renvoyer depuis DynamoDB. Par défaut, le résolveur AWS AppSync DynamoDB renvoie uniquement les attributs projetés dans l'index. Les valeurs prises en charge sont : + `ALL_ATTRIBUTES` Renvoie tous les attributs d'élément de la table ou de 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` Renvoie 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`ProjectionExpression`. Cette valeur de retour revient à spécifier `ProjectionExpression` sans spécifier de valeur pour`AttributesToGet`. + `totalSegments?: number` (facultatif) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Déclaration de type** + `basePartitionKey?: string` (facultatif) La clé de partition de la table de base à utiliser lors d'une opération de synchronisation. Ce champ permet d'effectuer une opération de synchronisation lorsque la table utilise une clé de partition personnalisée. + `deltaIndexName?: string` (facultatif) Index utilisé pour l'opération de synchronisation. Cet index est nécessaire pour activer une opération de synchronisation sur l'ensemble de la table delta store lorsque la table utilise une clé de partition personnalisée. L'opération de synchronisation sera effectuée sur le GSI (créé sur `gsi_ds_pk` et`gsi_ds_sk`). + `filter?: DynamoDBFilterObject | null` (facultatif) Filtre facultatif à appliquer aux résultats après les avoir extraits du tableau. + `lastSync?: number` (facultatif) Moment, en millisecondes, auquel la dernière opération de synchronisation réussie a commencé. Si spécifié, seuls les éléments qui ont changé après `lastSync` sont retournés. Ce champ ne doit être rempli qu'après avoir récupéré toutes les pages d'une opération de synchronisation initiale. En cas d'omission, les résultats de la table de base seront renvoyés. Dans le cas contraire, les résultats de la table delta seront renvoyés. + `limit?: number | null` (facultatif) Nombre maximal facultatif d'éléments à évaluer simultanément. 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?: string | null` (facultatif) **`Type DynamoDBUpdateInput`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Déclaration de type** + `_version?: number` (facultatif) + `condition?: DynamoDBFilterObject` (facultatif) Lorsque vous mettez à jour un objet dans DynamoDB, vous pouvez éventuellement spécifier une expression conditionnelle 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. + `customPartitionKey?: string` (facultatif) Lorsqu'elle est activée, la `customPartitionKey` valeur modifie le format des `ds_pk` enregistrements `ds_sk` et utilisés par la table de synchronisation delta lorsque le versionnement est activé. Lorsque cette option est activée, le traitement de l'`populateIndexFields`entrée est également activé. + `key: DynamoDBKey` (obligatoire) Paramètre obligatoire qui spécifie la clé de l'élément en cours de mise à jour dans DynamoDB. Les éléments DynamoDB peuvent avoir une seule clé de hachage ou des clés de hachage et de tri. + `populateIndexFields?: boolean` (facultatif) 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`. + `update: DynamoDBUpdateObject` Objet qui spécifie les attributs à mettre à jour ainsi que leurs nouvelles valeurs. L'objet de mise à jour peut être utilisé avec `add` `remove``replace`,`increment`,,`decrement`,`append`,`prepend`,`updateListItem`. ## Fonctions du module Amazon RDS Les fonctions du module Amazon RDS offrent une expérience améliorée lors de l'interaction avec les bases de données configurées avec l'API Amazon RDS Data. Le module est importé à l'aide de `@aws-appsync/utils/rds` : ``` import * as rds from '@aws-appsync/utils/rds'; ``` Les fonctions peuvent également être importées individuellement. Par exemple, l'importation ci-dessous utilise `sql` : ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Fonctions Vous pouvez utiliser les aides utilitaires du module AWS AppSync RDS pour interagir avec votre base de données. #### Select L'`select`utilitaire crée une `SELECT` instruction pour interroger votre base de données relationnelle. **Usage de base** Dans sa forme de base, vous pouvez spécifier la table que vous souhaitez interroger : ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // "SELECT * FROM "persons" return createPgStatement(select({table: 'persons'})); } ``` Notez que vous pouvez également spécifier le schéma dans l'identifiant de votre table : ``` import { select, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { // Generates statement: // SELECT * FROM "private"."persons" return createPgStatement(select({table: 'private.persons'})); } ``` **Spécification des colonnes** Vous pouvez définir des colonnes à l'aide de `columns` cette propriété. S'il n'est pas défini sur une valeur, la valeur par défaut est : `*` ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'name'] })); } ``` Vous pouvez également spécifier le tableau d'une colonne : ``` export function request(ctx) { // Generates statement: // SELECT "id", "persons"."name" // FROM "persons" return createPgStatement(select({ table: 'persons', columns: ['id', 'persons.name'] })); } ``` **Limites et compensations** Vous pouvez appliquer `limit` et répondre `offset` à la requête : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // LIMIT :limit // OFFSET :offset return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], limit: 10, offset: 40 })); } ``` **Commander par** Vous pouvez trier vos résultats à l'aide de `orderBy` cette propriété. Fournissez un tableau d'objets spécifiant la colonne et une `dir` propriété facultative : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" FROM "persons" // ORDER BY "name", "id" DESC return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}] })); } ``` **Filtres** Vous pouvez créer des filtres à l'aide de l'objet de condition spéciale : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}} })); } ``` Vous pouvez également combiner des filtres : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME and "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: {name: {eq: 'Stephane'}, id: {gt: 10}} })); } ``` Vous pouvez également créer des `OR` déclarations : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE "name" = :NAME OR "id" > :ID return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { or: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Vous pouvez également annuler une condition avec `not` : ``` export function request(ctx) { // Generates statement: // SELECT "id", "name" // FROM "persons" // WHERE NOT ("name" = :NAME AND "id" > :ID) return createPgStatement(select({ table: 'persons', columns: ['id', 'name'], where: { not: [ { name: { eq: 'Stephane'} }, { id: { gt: 10 } } ]} })); } ``` Vous pouvez également utiliser les opérateurs suivants pour comparer des valeurs : | | | Opérateur | Description | Types de valeurs possibles | | --- |--- |--- | | eq | Égal à | nombre, chaîne, booléen | | ne | Non égal à | nombre, chaîne, booléen | | le | Inférieur ou égal à | nombre, chaîne | | lt | Inférieur à | nombre, chaîne | | gm | Supérieur ou égal à | nombre, chaîne | | gt | Supérieur à | nombre, chaîne | | contient | Comme | chaîne | | NE CONTIENT PAS | Pas comme | chaîne | | Commence par | Commence par le préfixe | chaîne | | between | Entre deux valeurs | nombre, chaîne | | L'attribut existe | L'attribut n'est pas nul | nombre, chaîne, booléen | | size | vérifie la longueur de l'élément | chaîne | #### Insert L'`insert`utilitaire fournit un moyen simple d'insérer des éléments d'une seule ligne dans votre base de données avec l'`INSERT`opération. **Insertions d'un seul article** Pour insérer un élément, spécifiez le tableau, puis transmettez votre objet de valeurs. Les clés d'objet sont mappées aux colonnes de votre tableau. Les noms des colonnes sont automatiquement ignorés et les valeurs sont envoyées à la base de données à l'aide de la variable map : ``` import { insert, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) return createMySQLStatement(insertStatement) } ``` **Cas d'utilisation de MySQL** Vous pouvez combiner un `insert` suivi d'un `select` pour récupérer la ligne que vous avez insérée : ``` import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); const selectStatement = select({ table: 'persons', columns: '*', where: { id: { eq: values.id } }, limit: 1, }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) // and // SELECT * // FROM `persons` // WHERE `id` = :ID return createMySQLStatement(insertStatement, selectStatement) } ``` **Cas d'utilisation de Postgres** Avec Postgres, vous pouvez l'utiliser [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)pour obtenir des données à partir de la ligne que vous avez insérée. Il accepte `*` un tableau de noms de colonnes : ``` import { insert, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values, returning: '*' }); // Generates statement: // INSERT INTO "persons"("name") // VALUES(:NAME) // RETURNING * return createPgStatement(insertStatement) } ``` #### Mettre à jour L'`update`utilitaire vous permet de mettre à jour les lignes existantes. Vous pouvez utiliser l'objet condition pour appliquer des modifications aux colonnes spécifiées dans toutes les lignes qui répondent à la condition. Supposons, par exemple, que nous ayons un schéma qui nous permet de réaliser cette mutation. Nous voulons mettre à jour les `name` de `Person` avec la `id` valeur de`3`, mais uniquement si nous les connaissons (`known_since`) depuis l'année `2000` : ``` mutation Update { updatePerson( input: {id: 3, name: "Jon"}, condition: {known_since: {ge: "2000"}} ) { id name } } ``` Notre résolveur de mises à jour ressemble à ceci : ``` import { update, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id, ...values }, condition } = ctx.args; const where = { ...condition, id: { eq: id }, }; const updateStatement = update({ table: 'persons', values, where, returning: ['id', 'name'], }); // Generates statement: // UPDATE "persons" // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` Nous pouvons ajouter une vérification à notre condition pour nous assurer que seule la ligne dont la clé primaire est `id` égale à `3` est mise à jour. De même, pour Postgres`inserts`, vous pouvez utiliser `returning` pour renvoyer les données modifiées. #### Supprimer L'`remove`utilitaire vous permet de supprimer des lignes existantes. Vous pouvez utiliser l'objet de condition sur toutes les lignes qui répondent à la condition. Notez qu'il `delete` s'agit d'un mot clé réservé dans JavaScript. `remove`doit être utilisé à la place : ``` import { remove, createPgStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: { id }, condition } = ctx.args; const where = { ...condition, id: { eq: id } }; const deleteStatement = remove({ table: 'persons', where, returning: ['id', 'name'], }); // Generates statement: // DELETE "persons" // WHERE "id" = :ID // RETURNING "id", "name" return createPgStatement(updateStatement) } ``` ### Forçage de type Dans certains cas, vous souhaiterez peut-être plus de précisions quant au type d'objet correct à utiliser dans votre déclaration. Vous pouvez utiliser les indications de type fournies pour spécifier le type de vos paramètres. AWS AppSync prend en charge les [mêmes indications de type](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) que l'API Data. Vous pouvez convertir vos paramètres en utilisant les `typeHint` fonctions du AWS AppSync `rds` module. L'exemple suivant vous permet d'envoyer un tableau sous forme de valeur qui est convertie en objet JSON. Nous utilisons l'`->`opérateur pour récupérer l'élément situé `index` `2` dans le tableau JSON : ``` import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const arr = ctx.args.list_of_ids const statement = sql`select ${typeHint.JSON(arr)}->2 as value` return createPgStatement(statement) } export function response(ctx) { return toJsonObject(ctx.result)[0][0].value } ``` Le casting est également utile lors de la manipulation et de `DATE` la comparaison`TIME`, et `TIMESTAMP` : ``` import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const when = ctx.args.when const statement = select({ table: 'persons', where: { createdAt : { gt: typeHint.DATETIME(when) } } }) return createPgStatement(statement) } ``` Voici un autre exemple montrant comment envoyer la date et l'heure actuelles : ``` import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds'; export function request(ctx) { const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss') return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`) } ``` **Indications de type disponibles** + `typeHint.DATE`- Le paramètre correspondant est envoyé sous forme d'objet de `DATE` ce type à la base de données. Le format accepté est `YYYY-MM-DD`. + `typeHint.DECIMAL`- Le paramètre correspondant est envoyé sous forme d'objet de `DECIMAL` ce type à la base de données. + `typeHint.JSON`- Le paramètre correspondant est envoyé sous forme d'objet de `JSON` ce type à la base de données. + `typeHint.TIME`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `TIME` ce type à la base de données. Le format accepté est `HH:MM:SS[.FFF]`. + `typeHint.TIMESTAMP`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `TIMESTAMP` ce type à la base de données. Le format accepté est `YYYY-MM-DD HH:MM:SS[.FFF]`. + `typeHint.UUID`- La valeur de paramètre de chaîne correspondante est envoyée sous forme d'objet de `UUID` ce type à la base de données. # utilitaires d'exécution La `runtime` bibliothèque fournit des utilitaires permettant de contrôler ou de modifier les propriétés d'exécution de vos résolveurs et fonctions. ## Liste des utilitaires d'exécution **`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`** L'invocation de cette fonction interrompt l'exécution du gestionnaire, de la AWS AppSync fonction ou du résolveur actuel (Unit ou Pipeline Resolver) en fonction du contexte actuel. L'objet spécifié est renvoyé en tant que résultat. + Lorsqu'il est appelé dans un gestionnaire de demande de AWS AppSync fonction, la source de données et le gestionnaire de réponse sont ignorés, et le gestionnaire de demande de fonction suivant (ou le gestionnaire de réponse du résolveur de pipeline s'il s'agit de la dernière fonction) est appelé. AWS AppSync + Lorsqu'il est appelé dans un gestionnaire de demandes de résolution de AWS AppSync pipeline, l'exécution du pipeline est ignorée et le gestionnaire de réponse du résolveur de pipeline est appelé immédiatement. + Lorsqu'il `returnOptions` est `skipTo` défini sur « END », l'exécution du pipeline est ignorée et le gestionnaire de réponse du résolveur de pipeline est appelé immédiatement. + Lorsqu'il `returnOptions` est `skipTo` défini sur « NEXT », l'exécution de la fonction est ignorée et le gestionnaire de pipeline suivant est appelé. **Exemple** ``` import { runtime } from '@aws-appsync/utils' export function request(ctx) { runtime.earlyReturn({ hello: 'world' }) // code below is not executed return ctx.args } // never called because request returned early export function response(ctx) { return ctx.result } ``` # Des aides temporelles dans util.time La variable `util.time` contient les méthodes datetime pour aider à générer les horodatages, à convertir d'un format datetime à l'autre et à analyser les chaînes datetime. La syntaxe des formats datetime est basée sur [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)laquelle vous pouvez vous référer pour obtenir de la documentation supplémentaire. ## Liste des heures et des outils **`util.time.nowISO8601()`** Renvoie une représentation sous forme de chaîne de l'UTC au [ISO8601format](https://en.wikipedia.org/wiki/ISO_8601). **`util.time.nowEpochSeconds()`** Renvoie le nombre de secondes entre l'époque Unix 1970-01-01T00:00:00Z et maintenant. **`util.time.nowEpochMilliSeconds()`** Renvoie le nombre de millisecondes entre l'époque Unix 1970-01-01T00:00:00Z et maintenant. **`util.time.nowFormatted(String)`** Renvoie une chaîne de l'horodatage actuel (UTC) à l'aide du format spécifié à partir d'un type d'entrée String (chaîne). **`util.time.nowFormatted(String, String)`** Renvoie une chaîne de l'horodatage actuel pour un fuseau horaire à l'aide du format et du fuseau spécifiés à partir de types d'entrée String (chaîne). **`util.time.parseFormattedToEpochMilliSeconds(String, String)`** Analyse un horodatage transmis sous forme de chaîne avec un format contenant un fuseau horaire, puis renvoie l'horodatage en millisecondes depuis l'époque. **`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`** Analyse un horodatage transmis sous forme de chaîne avec un format et un fuseau horaire, puis renvoie l'horodatage en millisecondes depuis l'époque. **`util.time.parseISO8601ToEpochMilliSeconds(String)`** Analyse un ISO8601 horodatage transmis sous forme de chaîne, puis renvoie l'horodatage en millisecondes depuis l'époque. **`util.time.epochMilliSecondsToSeconds(long)`** Convertit une époque Unix en millisecondes en une époque Unix en secondes. **`util.time.epochMilliSecondsToISO8601(long)`** Convertit l'horodatage d'une époque en millisecondes en horodatage. ISO8601 **`util.time.epochMilliSecondsToFormatted(long, String)`** Convertit l'horodatage d'une époque en millisecondes, transmis sous sa forme la plus longue, en un horodatage formaté selon le format fourni en UTC. **`util.time.epochMilliSecondsToFormatted(long, String, String)`** Convertit un horodatage en millisecondes d'époque, transmis sous forme de long, en un horodatage formaté selon le format fourni dans le fuseau horaire fourni. # Assistants DynamoDB dans util.dynamodb `util.dynamodb`contient des méthodes d'assistance qui facilitent l'écriture et la lecture de données dans Amazon DynamoDB, telles que le mappage automatique des types et le formatage. ## vers DynamoDB ### Liste des utilitaires de ToDynamoDB **`util.dynamodb.toDynamoDB(Object)`** Outil général de conversion d'objets pour DynamoDB qui convertit les objets d'entrée en une représentation DynamoDB appropriée. La façon dont il représente certains types est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. **Exemple de chaîne** ``` Input: util.dynamodb.toDynamoDB("foo") Output: { "S" : "foo" } ``` **Exemple de numéro** ``` Input: util.dynamodb.toDynamoDB(12345) Output: { "N" : 12345 } ``` **Exemple booléen** ``` Input: util.dynamodb.toDynamoDB(true) Output: { "BOOL" : true } ``` **Exemple de liste** ``` Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ]) Output: { "L" : [ { "S" : "foo" }, { "N" : 123 }, { "M" : { "bar" : { "S" : "baz" } } } ] } ``` **Exemple de carte** ``` Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "M" : { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } } ``` ## Utilitaires ToString ### Liste des utilitaires ToString **`util.dynamodb.toString(String)`** Convertit une chaîne d'entrée au format de chaîne DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toString("foo") Output: { "S" : "foo" } ``` **`util.dynamodb.toStringSet(List)`** Convertit une liste contenant des chaînes au format de jeu de chaînes DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ]) Output: { "SS" : [ "foo", "bar", "baz" ] } ``` ## Utils ToNumber ### Liste des utilitaires ToNumber **`util.dynamodb.toNumber(Number)`** Convertit un nombre au format numérique DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toNumber(12345) Output: { "N" : 12345 } ``` **`util.dynamodb.toNumberSet(List)`** Convertit une liste de nombres au format d'ensemble de numéros DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ]) Output: { "NS" : [ 1, 23, 4.56 ] } ``` ## Utilitaires ToBinary ### Liste des utilitaires ToBinary **`util.dynamodb.toBinary(String)`** Convertit les données binaires codées sous forme de chaîne base64 au format binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toBinary("foo") Output: { "B" : "foo" } ``` **`util.dynamodb.toBinarySet(List)`** Convertit une liste de données binaires codées sous forme de chaînes base64 au format d'ensemble binaire DynamoDB. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ]) Output: { "BS" : [ "foo", "bar", "baz" ] } ``` ## Utilitaires ToBoolean ### Liste des utilitaires ToBoolean **`util.dynamodb.toBoolean(Boolean)`** Convertit un booléen au format booléen DynamoDB approprié. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toBoolean(true) Output: { "BOOL" : true } ``` ## Utilitaires ToNull ### Liste des utilitaires ToNull **`util.dynamodb.toNull()`** Renvoie une valeur nulle au format DynamoDB nul. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toNull() Output: { "NULL" : null } ``` ## Utilitaires ToList ### Liste des utilitaires ToList **`util.dynamodb.toList(List)`** Convertit une liste d'objets au format de liste DynamoDB. Chaque élément de la liste est également converti au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ]) Output: { "L" : [ { "S" : "foo" }, { "N" : 123 }, { "M" : { "bar" : { "S" : "baz" } } } ] } ``` ## Utilitaires TomaP ### Liste des utilitaires de TomaP **`util.dynamodb.toMap(Map)`** Convertit une carte au format de carte DynamoDB. Chaque valeur de la carte est également convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "M" : { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } } ``` **`util.dynamodb.toMapValues(Map)`** Crée une copie de la carte où chaque valeur a été convertie au format DynamoDB approprié. La façon dont il représente certains objets imbriqués est clairement arrêtée : par exemple, il utilise les listes (« L ») plutôt que les ensembles (« SS », « NS », « BS »). ``` Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } ``` Cela est légèrement différent `util.dynamodb.toMap(Map)` car il renvoie uniquement le contenu de la valeur d'attribut DynamoDB, mais pas la valeur d'attribut complète elle-même. Par exemple, les instructions suivantes sont exactement identiques : ``` util.dynamodb.toMapValues() util.dynamodb.toMap()("M") ``` ## Utilitaires de l'objet S3 ### Liste des utilitaires de S3Object **`util.dynamodb.toS3Object(String key, String bucket, String region)`** Convertit la clé, le compartiment et la région en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", region = "baz") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo", \"bucket\" : \"bar", \"region\" : \"baz" } }" } ``` **`util.dynamodb.toS3Object(String key, String bucket, String region, String version)`** Convertit la clé, le compartiment, la région et la version facultative en représentation de l'objet DynamoDB S3. Cela renvoie un objet qui décrit la valeur de l'attribut DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", "baz", "beep") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" } ``` **`util.dynamodb.fromS3ObjectJson(String)`** Accepte la valeur de chaîne d'un objet DynamoDB S3 et renvoie une carte contenant la clé, le compartiment, la région et la version facultative. ``` Input: util.dynamodb.fromS3ObjectJson({ "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" }) Output: { "key" : "foo", "bucket" : "bar", "region" : "baz", "version" : "beep" } ``` # Assistants HTTP dans util.http L'`util.http`utilitaire fournit des méthodes d'assistance que vous pouvez utiliser pour gérer les paramètres des requêtes HTTP et pour ajouter des en-têtes de réponse. ## liste d'utilitaires util.http **`util.http.copyHeaders(headers)`** Copie les en-têtes de la carte, à l'exception des en-têtes HTTP restreints suivants : + transfer-encoding + connection + host + expect + keep-alive + upgrade + proxy-authenticate + proxy-authorization + te + content-length **`util.http.addResponseHeader(String, Object)`** Ajoute un seul en-tête personnalisé avec le nom (`String`) et la valeur (`Object`) de la réponse. Les limites suivantes s'appliquent : + Outre la liste des en-têtes restreints pour`copyHeaders(headers)`, les noms d'en-têtes ne peuvent correspondre à aucun des éléments suivants : + Access-Control-Allow-Credentials + Access-Control-Allow-Origin + Access-Control-Expose-Headers + Access-Control-Max-Age + Access-Control-Allow-Methods + Access-Control-Allow-Headers + Vary + Content-Type + Les noms d'en-tête ne peuvent pas commencer par les préfixes restreints `x-amzn-` ou`x-amz-`. + La taille des en-têtes de réponse personnalisés ne peut pas dépasser 4 Ko. Cela inclut les noms et les valeurs des en-têtes. + Vous devez définir chaque en-tête de réponse une fois par opération GraphQL. Toutefois, si vous définissez plusieurs fois un en-tête personnalisé portant le même nom, la définition la plus récente apparaît dans la réponse. Tous les en-têtes sont pris en compte dans la limite de taille d'en-tête, quel que soit leur nom. + Les en-têtes dont le nom est vide ou restreint `(String)` ou dont la valeur est nulle `(Object)` seront ignorés et produiront une `ResponseHeaderError` erreur qui sera ajoutée à la `errors` sortie de l'opération. ``` export function request(ctx) { util.http.addResponseHeader('itemsCount', 7) util.http.addResponseHeader('render', ctx.args.render) return {} } ``` **`util.http.addResponseHeaders(Map)`** Ajoute plusieurs en-têtes de réponse à la réponse à partir de la carte de noms `(String)` et de valeurs `(Object)` spécifiée. Les mêmes limites répertoriées pour la `addResponseHeader(String, Object)` méthode s'appliquent également à cette méthode. ``` export function request(ctx) { const headers = { headerInt: 12, headerString: 'stringValue', headerObject: { field1: 7, field2: 'string' } } util.http.addResponseHeaders(headers) return {} } ``` # Aides à la transformation dans util.transform `util.transform`contient des méthodes d'assistance qui facilitent l'exécution d'opérations complexes sur des sources de données. ## Liste des outils d'aide à la transformation **`util.transform.toDynamoDBFilterExpression(filterObject: DynamoDBFilterObject) : string`** Convertit une chaîne d'entrée en une expression de filtre à utiliser avec DynamoDB. Nous vous recommandons de l'utiliser `toDynamoDBFilterExpression` avec les [fonctions du module intégré](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html). **`util.transform.toElasticsearchQueryDSL(object: OpenSearchQueryObject) : string`** Convertit l'entrée donnée en son expression OpenSearch Query DSL équivalente, en la renvoyant sous forme de chaîne JSON. **Exemple de saisie :** ``` util.transform.toElasticsearchQueryDSL({ "upvotes":{ "ne":15, "range":[ 10, 20 ] }, "title":{ "eq":"hihihi", "wildcard":"h*i" } }) ``` **Exemple de sortie :** ``` { "bool":{ "must":[ { "bool":{ "must":[ { "bool":{ "must_not":{ "term":{ "upvotes":15 } } } }, { "range":{ "upvotes":{ "gte":10, "lte":20 } } } ] } }, { "bool":{ "must":[ { "term":{ "title":"hihihi" } }, { "wildcard":{ "title":"h*i" } } ] } } ] } } ``` L'opérateur par défaut est supposé être AND. **`util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter`** Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). Les paramètres et l'instruction de retour sont répertoriés ci-dessous : *Paramètres* + `objFilter`: `SubscriptionFilterObject` Objet d'`Map`entrée converti en objet d'`SubscriptionFilter`expression. + `ignoredFields`: `SubscriptionFilterExcludeKeysType` (facultatif) A `List` des noms de champs du premier objet qui seront ignorés. + `rules`: `SubscriptionFilterRuleObject` (facultatif) Un objet `Map` d'entrée avec des règles strictes qui est inclus lors de la construction de l'objet `SubscriptionFilter` d'expression. Ces règles strictes seront incluses dans l'objet `SubscriptionFilter` d'expression afin qu'au moins l'une des règles soit satisfaite pour passer le filtre d'abonnement. *Réponse* Retourne un `[SubscriptionFilter](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)`. **`util.transform.toSubscriptionFilter(Map, List)`** Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). Le premier argument est l'objet `Map` d'entrée converti en objet d'`SubscriptionFilter`expression. Le deuxième argument est un nom `List` de champ qui est ignoré dans le premier objet `Map` d'entrée lors de la construction de l'objet `SubscriptionFilter` d'expression. **`util.transform.toSubscriptionFilter(Map, List, Map)`** Convertit un objet `Map` d'entrée en objet d'`SubscriptionFilter`expression. La `util.transform.toSubscriptionFilter` méthode est utilisée comme entrée dans l'`extensions.setSubscriptionFilter()`extension. Pour plus d'informations, consultez la section [Extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). **`util.transform.toDynamoDBConditionExpression(conditionObject)`** Crée une expression de condition DynamoDB. ## Arguments du filtre d'abonnement Le tableau suivant explique comment les arguments des utilitaires suivants sont définis : + `Util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter` ------ #### [ Argument 1: Map ] L'argument 1 est un `Map` objet dont les valeurs clés sont les suivantes : + noms de champs + « et » + « ou » Pour les noms de champs sous forme de clés, les conditions relatives aux entrées de ces champs sont sous la forme de`"operator" : "value"`. L'exemple suivant montre comment ajouter des entrées au `Map` : ``` "field_name" : { "operator1" : value } ## We can have multiple conditions for the same field_name: "field_name" : { "operator1" : value "operator2" : value . . . } ``` Lorsqu'un champ comporte au moins deux conditions, toutes ces conditions sont considérées comme utilisant l'opération OR. L'entrée `Map` peut également comporter des touches « et » et « ou », ce qui implique que toutes les entrées qu'elles contiennent doivent être jointes en utilisant la logique ET ou ou selon la clé. Les valeurs clés « et » et « ou » supposent un ensemble de conditions. ``` "and" : [ { "field_name1" : { "operator1" : value } }, { "field_name2" : { "operator1" : value } }, . . ]. ``` Notez que vous pouvez imbriquer « et » et « ou ». C'est-à-dire que vous pouvez avoir imbriqué « et » /"ou » dans un autre bloc « et » /"ou ». Toutefois, cela ne fonctionne pas pour les champs simples. ``` "and" : [ { "field_name1" : { "operator" : value } }, { "or" : [ { "field_name2" : { "operator" : value } }, { "field_name3" : { "operator" : value } } ]. ``` L'exemple suivant montre une entrée de l'*argument 1* utilisant`util.transform.toSubscriptionFilter(Map) : Map`. **Entrée (s)** Argument 1 : Carte : ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 2000 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` **Sortie** Le résultat est un `Map` objet : ``` { "filterGroup": [ { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 2: List ] L'argument 2 contient des noms `List` de champs qui ne doivent pas être pris en compte dans l'entrée `Map` (argument 1) lors de la construction de l'objet `SubscriptionFilter` d'expression. Ils `List` peuvent également être vides. L'exemple suivant montre les entrées de l'argument 1 et de l'argument 2 en utilisant`util.transform.toSubscriptionFilter(Map, List) : Map`. **Entrée (s)** Argument 1 : Carte : ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argument 2 : Liste : ``` ["percentageUp", "author"] ``` **Sortie** Le résultat est un `Map` objet : ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 3: Map ] L'argument 3 est un `Map` objet dont les noms de champs sont des valeurs clés (il ne peut pas y avoir « et » ou « ou »). Pour les noms de champs sous forme de clés, les conditions relatives à ces champs sont des entrées sous la forme de`"operator" : "value"`. Contrairement à l'argument 1, l'argument 3 ne peut pas avoir plusieurs conditions dans la même clé. De plus, l'argument 3 ne contient pas de clause « et » ou « ou », il n'y a donc aucune imbrication non plus. L'argument 3 représente une liste de règles strictes, qui sont ajoutées à l'objet `SubscriptionFilter` d'expression afin qu'**au moins l'une** de ces conditions soit remplie pour passer le filtre. ``` { "fieldname1": { "operator": value }, "fieldname2": { "operator": value } } . . . ``` L'exemple suivant montre les entrées des *arguments 1*, *2* et *3* en utilisant`util.transform.toSubscriptionFilter(Map, List, Map) : Map`. **Entrée (s)** Argument 1 : Carte : ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "lt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argument 2 : Liste : ``` ["percentageUp", "author"] ``` Argument 3 : Carte : ``` { "upvotes": { "gte": 250 }, "author": { "eq": "Person1" } } ``` **Sortie** Le résultat est un `Map` objet : ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "upvotes", "operator": "gte", "value": 250 } ] }, { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "author", "operator": "eq", "value": "Person1" } ] } ] } ``` ------ # assistants de chaîne dans util.str `util.str`contient des méthodes pour faciliter les opérations courantes sur les chaînes de caractères. ## liste des utilitaires de util.str **`util.str.normalize(String, String)`** Normalise une chaîne en utilisant l'une des quatre formes de normalisation Unicode : NFC, NFD, NFKC ou NFKD. Le premier argument est la chaîne à normaliser. Le deuxième argument est « nfc », « nfd », « nfkc » ou « nfkd », spécifiant le type de normalisation à utiliser pour le processus de normalisation. # Extensions `extensions`contient un ensemble de méthodes permettant d'effectuer des actions supplémentaires dans vos résolveurs. ## Extensions de mise en cache **`extensions.evictFromApiCache(typeName: string, fieldName: string, keyValuePair: Record) : Object`** Élimine un élément du cache AWS AppSync côté serveur. Le premier argument est le nom du type. Le deuxième argument est le nom du champ. Le troisième argument est un objet contenant des éléments de paire clé-valeur qui spécifient la valeur de la clé de mise en cache. Vous devez placer les éléments dans l'objet dans le même ordre que les clés de mise en cache dans le résolveur mis en cache. `cachingKey` Pour plus d'informations sur la mise en cache, consultez la section Comportement de [mise en cache.](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html#caching-behavior) **Exemple 1 :** Cet exemple évacue les éléments mis en cache pour un résolveur appelé `Query.allClasses` sur lequel une clé de mise en cache appelée a été utilisée. `context.arguments.semester` Lorsque la mutation est appelée et que le résolveur s'exécute, si une entrée est correctement effacée, la réponse contient une `apiCacheEntriesDeleted` valeur dans l'objet extensions qui indique le nombre d'entrées supprimées. ``` import { util, extensions } from '@aws-appsync/utils'; export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.evictFromApiCache('Query', 'allClasses', { 'context.arguments.semester': ctx.args.semester, }); return null; } ``` Cette fonction **ne fonctionne que** pour les mutations, pas pour les requêtes. ## Extensions d'abonnement **`extensions.setSubscriptionFilter(filterJsonObject)`** Définit des filtres d'abonnement améliorés. Chaque événement de notification d'abonnement est évalué par rapport aux filtres d'abonnement fournis et envoie des notifications aux clients si tous les filtres sont conformes`true`. L'argument est `filterJsonObject` (Vous trouverez plus d'informations sur cet argument ci-dessous dans la filterJsonObject section *Argument :*). Consultez la section [Filtrage amélioré des abonnements](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html). Vous pouvez utiliser cette fonction d'extension uniquement dans le gestionnaire de réponses d'un résolveur d'abonnement. Nous vous recommandons également de l'utiliser `util.transform.toSubscriptionFilter` pour créer votre filtre. **`extensions.setSubscriptionInvalidationFilter(filterJsonObject)`** Définit les filtres d'invalidation des abonnements. Les filtres d'abonnement sont évalués par rapport à la charge utile d'invalidation, puis invalident un abonnement donné s'ils sont évalués à. `true` L'argument est `filterJsonObject` (Vous trouverez plus d'informations sur cet argument ci-dessous dans la filterJsonObject section *Argument :*). Consultez la section [Filtrage amélioré des abonnements](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html). Vous pouvez utiliser cette fonction d'extension uniquement dans le gestionnaire de réponses d'un résolveur d'abonnement. Nous vous recommandons également de l'utiliser `util.transform.toSubscriptionFilter` pour créer votre filtre. **`extensions.invalidateSubscriptions(invalidationJsonObject)`** Utilisé pour initier l'invalidation d'un abonnement suite à une mutation. L'argument est `invalidationJsonObject` (Vous trouverez plus d'informations sur cet argument ci-dessous dans la invalidationJsonObject section *Argument :*). Cette extension ne peut être utilisée que dans les modèles de mappage des réponses des résolveurs de mutations. Vous ne pouvez utiliser qu'au maximum cinq appels de `extensions.invalidateSubscriptions()` méthode uniques par requête. Si vous dépassez cette limite, vous recevrez une erreur GraphQL. ## Argument : filterJsonObject L'objet JSON définit des filtres d'abonnement ou d'invalidation. Il s'agit d'un ensemble de filtres dans un`filterGroup`. Chaque filtre est un ensemble de filtres individuels. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 } ] }, { "filters" : [ { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` Chaque filtre possède trois attributs : + `fieldName`— Le champ du schéma GraphQL. + `operator`— Le type d'opérateur. + `value`— Les valeurs à comparer à la `fieldName` valeur de la notification d'abonnement. Voici un exemple d'attribution de ces attributs : ``` { "fieldName" : "severity", "operator" : "le", "value" : context.result.severity } ``` ## Argument : invalidationJsonObject `invalidationJsonObject`définit les éléments suivants : + `subscriptionField`— L'abonnement au schéma GraphQL à invalider. Un seul abonnement, défini comme une chaîne dans le`subscriptionField`, est considéré comme invalide. + `payload`— Une liste de paires clé-valeur utilisée comme entrée pour invalider les abonnements si le filtre d'invalidation est évalué par rapport à leurs valeurs. `true` L'exemple suivant invalide les clients abonnés et connectés utilisant l'`onUserDelete`abonnement lorsque le filtre d'invalidation défini dans le résolveur d'abonnement est évalué par rapport à la valeur. `true` `payload` ``` export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.invalidateSubscriptions({ subscriptionField: 'onUserDelete', payload: { group: 'Developer', type: 'Full-Time' }, }); return ctx.result; } ``` # Assistants XML dans le fichier util.xml `util.xml`contient des méthodes pour faciliter la conversion de chaînes XML. ## Liste des utilitaires du fichier util.xml **`util.xml.toMap(String) : Object`** Convertit une chaîne XML en dictionnaire. **Exemple 1 :** ``` Input: 1 Getting started with GraphQL Output (object): { "posts":{ "post":{ "id":1, "title":"Getting started with GraphQL" } } } ``` **Exemple 2 :** ``` Input: 1 Getting started with GraphQL 2 Getting started with AppSync Output (JavaScript object): { "posts":{ "post":[ { "id":1, "title":"Getting started with GraphQL" }, { "id":2, "title":"Getting started with AppSync" } ] } } ``` **`util.xml.toJsonString(String, Boolean?) : String`** Convertit une chaîne XML en chaîne JSON. Ceci est similaire à`toMap`, sauf que la sortie est une chaîne. Cela est utile si vous souhaitez convertir et renvoyer directement la réponse XML à partir d'un objet HTTP vers JSON. Vous pouvez définir un paramètre booléen facultatif pour déterminer si vous souhaitez coder le JSON en chaîne.