Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS AppSync référence du résolveur () JavaScript
Les sections suivantes contiennent les références relatives à l'`APPSYNC_JS`exécution et au JavaScript résolveur :
+ [ JavaScriptprésentation des résolveurs](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) - En savoir plus sur le fonctionnement des résolveurs dans. AWS AppSync
+ [Référence de l'objet de contexte du résolveur](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) : en savoir plus sur l'objet de contexte et son utilisation dans les résolveurs.
+ [ JavaScript fonctionnalités d'exécution pour les résolveurs et les fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) - En savoir plus sur les fonctionnalités d'exécution prises en charge et sur l'utilisation d'utilitaires pour simplifier le code.
+ [ JavaScriptréférence des fonctions de résolution pour DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) - En savoir plus sur la façon dont les résolveurs interagissent avec DynamoDB.
+ [ JavaScriptréférence de la fonction de résolution pour OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-elasticsearch-js.html) - En savoir plus sur la structure de demande et de réponse du résolveur et sur les interactions avec OpenSearch le service.
+ [ JavaScript référence de la fonction de résolution pour Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html) - En savoir plus sur la structure de demande et de réponse du résolveur et sur les interactions avec Lambda.
+ [ JavaScriptréférence de la fonction de résolution pour la source de EventBridge données](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-eventbridge-js.html) - En savoir plus sur la structure des demandes et réponses du résolveur et sur les interactions avec. EventBridge
+ [ JavaScript référence de la fonction de résolution pour la source de données None](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-none-js.html) - En savoir plus sur la structure de demande et de réponse du résolveur et les interactions avec les sources de données NONE.
+ [ JavaScript référence de la fonction de résolution pour HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-http-js.html) - En savoir plus sur la structure des demandes et réponses du résolveur et sur les interactions avec les points de terminaison HTTP.
+ [ JavaScript référence de la fonction de résolution pour Amazon RDS](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-rds-js.html) - En savoir plus sur la structure du résolveur et les interactions avec RDS.
+ [ JavaScript référence de la fonction de résolution pour Amazon Bedrock](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-bedrock-js.html) - En savoir plus sur la structure du résolveur et les interactions avec Amazon Bedrock.
# AWS AppSync JavaScript vue d'ensemble des résolveurs
AWS AppSync vous permet de répondre aux requêtes GraphQL en effectuant des opérations sur vos sources de données. Pour chaque champ GraphQL sur lequel vous souhaitez exécuter une requête, une mutation ou un abonnement, un résolveur doit être joint.
Les résolveurs sont les connecteurs entre GraphQL et une source de données. Ils expliquent AWS AppSync comment traduire une requête GraphQL entrante en instructions pour votre source de données principale et comment traduire la réponse de cette source de données en réponse GraphQL. Avec AWS AppSync, vous pouvez écrire vos résolveurs en les utilisant JavaScript et les exécuter dans l'environnement AWS AppSync (`APPSYNC_JS`).
AWS AppSync vous permet d'écrire des résolveurs d'unités ou des résolveurs de pipeline composés de plusieurs AWS AppSync fonctions dans un pipeline.
## Fonctionnalités d'exécution prises en charge
Le AWS AppSync JavaScript moteur d'exécution fournit un sous-ensemble de JavaScript bibliothèques, d'utilitaires et de fonctionnalités. Pour une liste complète des fonctionnalités prises en charge par le `APPSYNC_JS` moteur d'exécution, voir [Fonctionnalités JavaScript d'exécution pour les résolveurs et les fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
## Résolveurs d'unités
Un résolveur d'unités est composé d'un code qui définit un gestionnaire de demandes et de réponses qui sont exécutés sur une source de données. Le gestionnaire de demandes prend un objet de contexte comme argument et renvoie la charge utile de la demande utilisée pour appeler votre source de données. Le gestionnaire de réponses reçoit une charge utile en retour de la source de données avec le résultat de la demande exécutée. Le gestionnaire de réponse transforme la charge utile en réponse GraphQL pour résoudre le champ GraphQL. Dans l'exemple ci-dessous, un résolveur extrait un élément d'une source de données DynamoDB :
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({ key: { id: ctx.args.id } });
}
export const response = (ctx) => ctx.result;
```
## Anatomie d'un résolveur de JavaScript pipeline
Un résolveur de pipeline est composé d'un code qui définit un gestionnaire de requêtes et de réponses et d'une liste de fonctions. Chaque fonction possède un gestionnaire de **requêtes** et de **réponses** qu'elle exécute sur une source de données. Lorsqu'un résolveur de pipeline délègue des exécutions à une liste de fonctions, il n'est donc lié à aucune source de données. Les résolveurs d'unité et les fonctions sont des primitifs qui exécutent l'opération sur les sources de données.
### Gestionnaire de requêtes Pipeline Resolver
Le gestionnaire de requêtes d'un résolveur de pipeline (étape précédente) vous permet d'exécuter une certaine logique de préparation avant d'exécuter les fonctions définies.
### Liste des fonctions
La liste des fonctions d'un résolveur de pipeline est exécutée dans l'ordre. Le résultat de l'évaluation du gestionnaire de demandes du résolveur de pipeline est mis à la disposition de la première fonction sous forme de. `ctx.prev.result` Le résultat de l'évaluation de chaque fonction est disponible pour la fonction suivante sous forme de`ctx.prev.result`.
### Gestionnaire de réponses Pipeline Resolver
Le gestionnaire de réponse d'un résolveur de pipeline vous permet d'exécuter une certaine logique finale entre la sortie de la dernière fonction et le type de champ GraphQL attendu. La sortie de la dernière fonction de la liste des fonctions est disponible dans le gestionnaire de réponse du résolveur de pipeline sous `ctx.prev.result` la forme ou. `ctx.result`
### Flux d'exécution
Étant donné qu'un résolveur de pipeline comprend deux fonctions, la liste ci-dessous représente le flux d'exécution lorsque le résolveur est invoqué :
1. Gestionnaire de requêtes Pipeline Resolver
1. Fonction 1 : gestionnaire de demandes de fonctions
1. Fonction 1 : Appel de source de données
1. Fonction 1 : gestionnaire de réponse fonctionnelle
1. Fonction 2 : gestionnaire de demandes de fonctions
1. Fonction 2 : Appel de source de données
1. Fonction 2 : gestionnaire de réponse fonctionnelle
1. Gestionnaire de réponses Pipeline Resolver
![\[GraphQL request flow diagram showing interactions between request, data sources, and response components.\]](http://docs.aws.amazon.com/fr_fr/appsync/latest/devguide/images/appsync-js-resolver-logic.png)
### Utilitaires intégrés utiles à l'`APPSYNC_JS`exécution
Les utilitaires suivants peuvent vous aider si vous travaillez avec des résolveurs de pipeline.
#### ctx.stash
Le stash est un objet mis à disposition dans chaque résolveur et chaque gestionnaire de demandes et de réponses de fonctions. La même instance de stash passe par une seule exécution du résolveur. Cela signifie que vous pouvez utiliser le stash pour transmettre des données arbitraires entre les gestionnaires de requêtes et de réponses et entre les fonctions d'un résolveur de pipeline. Vous pouvez tester la réserve comme un JavaScript objet normal.
#### ctx.prev.result
`ctx.prev.result` représente le résultat de l'opération précédente exécutée dans le pipeline. Si l'opération précédente était le gestionnaire de demandes du résolveur de pipeline, elle `ctx.prev.result` est alors mise à la disposition de la première fonction de la chaîne. Si l'opération précédente est la première fonction, alors `ctx.prev.result` représente le résultat de la première fonction et il est disponible pour la seconde fonction du pipeline. Si l'opération précédente était la dernière fonction, elle `ctx.prev.result` représente la sortie de la dernière fonction et est mise à la disposition du gestionnaire de réponse du résolveur de pipeline.
#### util.error
L'utilitaire `util.error` est utile pour envoyer une erreur de champ. `util.error`L'utilisation à l'intérieur d'un gestionnaire de demandes ou de réponses de fonction génère immédiatement une erreur de champ, ce qui empêche l'exécution des fonctions suivantes. Pour plus de détails et pour d'autres `util.error` signatures, consultez les [fonctionnalités JavaScript d'exécution pour les résolveurs et les fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
#### Erreur Util.AppendError
`util.appendError`est similaire à`util.error()`, avec la principale différence qu'il n'interrompt pas l'évaluation du gestionnaire. Il signale plutôt qu'une erreur s'est produite dans le champ, mais permet d'évaluer le gestionnaire et, par conséquent, de renvoyer des données. L'utilisation de `util.appendError` dans une fonction ne perturbera pas le flux d'exécution du pipeline. Pour plus de détails et pour d'autres `util.error` signatures, consultez les [fonctionnalités JavaScript d'exécution relatives aux résolveurs et aux fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
#### Temps d'exécution. Retour anticipé
La `runtime.earlyReturn` fonction vous permet de revenir prématurément à n'importe quelle fonction de requête. L'utilisation de `runtime.earlyReturn` l'intérieur d'un gestionnaire de demandes de résolution sera renvoyée par le résolveur. L'appeler depuis un gestionnaire de demandes de AWS AppSync fonction retournera depuis la fonction et poursuivra l'exécution vers la fonction suivante du pipeline ou vers le gestionnaire de réponse du résolveur.
### Écrire des résolveurs de pipeline
Un résolveur de pipeline possède également un gestionnaire de requêtes et de réponses entourant l'exécution des fonctions du pipeline : son gestionnaire de demandes est exécuté avant la demande de la première fonction, et son gestionnaire de réponse est exécuté après la réponse de la dernière fonction. Le gestionnaire de requêtes Resolver peut configurer les données à utiliser par les fonctions du pipeline. Le gestionnaire de réponse du résolveur est chargé de renvoyer les données correspondant au type de sortie du champ GraphQL. Dans l'exemple ci-dessous, un gestionnaire de demandes de résolution définit `allowedGroups` ; les données renvoyées doivent appartenir à l'un de ces groupes. Cette valeur peut être utilisée par les fonctions du résolveur pour demander des données. Le gestionnaire de réponses du résolveur effectue une dernière vérification et filtre le résultat pour s'assurer que seuls les éléments appartenant aux groupes autorisés sont renvoyés.
```
import { util } from '@aws-appsync/utils';
/**
* Called before the request function of the first AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
ctx.stash.allowedGroups = ['admin'];
ctx.stash.startedAt = util.time.nowISO8601();
return {};
}
/**
* Called after the response function of the last AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const result = [];
for (const item of ctx.prev.result) {
if (ctx.stash.allowedGroups.indexOf(item.group) > -1) result.push(item);
}
return result;
}
```
#### AWS AppSync Fonctions d'écriture
AWS AppSync les fonctions vous permettent d'écrire une logique commune que vous pouvez réutiliser dans plusieurs résolveurs de votre schéma. Par exemple, vous pouvez avoir une AWS AppSync fonction appelée `QUERY_ITEMS` qui est chargée de demander des éléments à partir d'une source de données Amazon DynamoDB. Pour les résolveurs avec lesquels vous souhaitez interroger des éléments, ajoutez simplement la fonction au pipeline du résolveur et fournissez l'index de requête à utiliser. La logique n'a pas besoin d'être réimplémentée.
## Sujets supplémentaires
**Rubriques**
+ [Exemple de résolveur de pipeline avec Amazon DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/writing-code.html)
+ [Configuration des utilitaires pour l'`APPSYNC_JS`environnement d'exécution](https://docs.aws.amazon.com/appsync/latest/devguide/utility-resolvers.html)
+ [Regroupement et sources TypeScript de cartes pour l'environnement d'exécution `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/additional-utilities.html)
+ [Tester votre résolveur et vos gestionnaires de fonctions](https://docs.aws.amazon.com/appsync/latest/devguide/test-resolvers.html)
+ [Migration de VTL vers JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/migrating-resolvers.html)
+ [Choisir entre un accès direct à une source de données ou un proxy via une source de données Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/choosing-data-source.html)
# Exemple de résolveur de pipeline avec Amazon DynamoDB
Supposons que vous souhaitiez associer un résolveur de pipeline à un champ nommé `getPost(id:ID!)` qui renvoie un `Post` type provenant d'une source de données Amazon DynamoDB avec la requête GraphQL suivante :
```
getPost(id:1){
id
title
content
}
```
Tout d'abord, attachez un résolveur simple à l'`Query.getPost`aide du code ci-dessous. Il s'agit d'un exemple de code de résolution simple. Aucune logique n'est définie dans le gestionnaire de demandes, et le gestionnaire de réponse renvoie simplement le résultat de la dernière fonction.
```
/**
* Invoked **before** the request handler of the first AppSync function in the pipeline.
* The resolver `request` handler allows to perform some preparation logic
* before executing the defined functions in your pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
return {}
}
/**
* Invoked **after** the response handler of the last AppSync function in the pipeline.
* The resolver `response` handler allows to perform some final evaluation logic
* from the output of the last function to the expected GraphQL field type.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
return ctx.prev.result
}
```
Définissez ensuite la fonction `GET_ITEM` qui extrait un article de votre source de données :
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
/**
* Request a single item from the attached DynamoDB table datasource
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
const { id } = ctx.args
return ddb.get({ key: { id } })
}
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx
if (error) {
return util.appendError(error.message, error.type, result)
}
return ctx.result
}
```
En cas d'erreur lors de la requête, le gestionnaire de réponse de la fonction ajoute une erreur qui sera renvoyée au client appelant dans la réponse GraphQL. Ajoutez la `GET_ITEM` fonction à la liste des fonctions de votre résolveur. Lorsque vous exécutez la requête, le gestionnaire de requêtes de la `GET_ITEM` fonction utilise les utilitaires fournis par le module AWS AppSync DynamoDB pour créer une `DynamoDBGetItem` demande en utilisant la clé. `id` `ddb.get({ key: { id } })`génère l'`GetItem`opération appropriée :
```
{
"operation" : "GetItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
AWS AppSync utilise la demande pour récupérer les données depuis Amazon DynamoDB. Une fois les données renvoyées, elles sont gérées par le gestionnaire de réponses de la `GET_ITEM` fonction, qui vérifie les erreurs puis renvoie le résultat.
```
{
"result" : {
"id": 1,
"title": "hello world",
"content": ""
}
}
```
Enfin, le gestionnaire de réponses du résolveur renvoie directement le résultat.
## Travailler avec des erreurs
Si une erreur se produit dans votre fonction lors d'une demande, elle sera disponible dans le gestionnaire de réponse de votre fonction dans`ctx.error`. Vous pouvez ajouter l'erreur à votre réponse GraphQL à l'aide `util.appendError` de l'utilitaire. Vous pouvez rendre l'erreur accessible aux autres fonctions du pipeline en utilisant le stash. Consultez l'exemple ci-dessous :
```
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx;
if (error) {
if (!ctx.stash.errors) ctx.stash.errors = []
ctx.stash.errors.push(ctx.error)
return util.appendError(error.message, error.type, result);
}
return ctx.result;
}
```
# Configuration des utilitaires pour l'`APPSYNC_JS`environnement d'exécution
AWS AppSync fournit deux bibliothèques qui facilitent le développement de résolveurs avec le `APPSYNC_JS` moteur d'exécution :
+ `@aws-appsync/eslint-plugin`- Détecte et corrige les problèmes rapidement pendant le développement.
+ `@aws-appsync/utils`- Fournit la validation de type et l'autocomplétion dans les éditeurs de code.
## Configuration du plugin eslint
[ESLint](https://eslint.org/)est un outil qui analyse statiquement votre code pour détecter rapidement les problèmes. Vous pouvez l'exécuter dans ESLint le cadre de votre pipeline d'intégration continue. `@aws-appsync/eslint-plugin`est un ESLint plugin qui détecte une syntaxe non valide dans votre code lorsque vous utilisez le `APPSYNC_JS` runtime. Le plugin vous permet d'obtenir rapidement des commentaires sur votre code pendant le développement sans avoir à transférer vos modifications dans le cloud.
`@aws-appsync/eslint-plugin`fournit deux ensembles de règles que vous pouvez utiliser pendant le développement.
**« plugin : @aws -appsync/base »** configure un ensemble de règles de base que vous pouvez utiliser dans votre projet :
| Règle | Description |
| --- | --- |
| non asynchrone | Les processus et les promesses asynchrones ne sont pas pris en charge. |
| sans attente | Les processus et les promesses asynchrones ne sont pas pris en charge. |
| pas de cours | Les cours ne sont pas pris en charge. |
| sans pour | forn'est pas pris en charge (sauf pour for-in etfor-of, qui sont pris en charge) |
| sans continuer | continue n’est pas pris en charge. |
| pas de générateurs | Les générateurs ne sont pas pris en charge. |
| aucun rendement | yield n’est pas pris en charge. |
| sans étiquettes | Les étiquettes ne sont pas prises en charge. |
| non, ça | thisle mot clé n'est pas pris en charge. |
| pas d'essai | La structure Try/Catch n'est pas prise en charge. |
| sans délai | Alors que les boucles ne sont pas prises en charge. |
| no-disallowed-unary-operators | \$1\$1--, et les opérateurs \$1 unaires ne sont pas autorisés. |
| no-disallowed-binary-operators | L'instanceofopérateur n'est pas autorisé. |
| sans promesse | Les processus et les promesses asynchrones ne sont pas pris en charge. |
**« plugin : @aws -appsync/recommended »** fournit des règles supplémentaires mais vous oblige également à ajouter des TypeScript configurations à votre projet.
| Règle | Description |
| --- | --- |
| aucune récursion | Les appels de fonction récursifs ne sont pas autorisés. |
| no-disallowed-methods | Certaines méthodes ne sont pas autorisées. Consultez la [référence](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) pour un ensemble complet de fonctions intégrées prises en charge. |
| no-function-passing | Il n'est pas permis de transmettre des fonctions en tant qu'arguments à des fonctions. |
| no-function-reassign | Les fonctions ne peuvent pas être réattribuées. |
| no-function-return | Les fonctions ne peuvent pas être la valeur de retour des fonctions. |
Pour ajouter le plugin à votre projet, suivez les étapes d'installation et d'utilisation décrites dans [Getting Started with ESLint](https://eslint.org/docs/latest/user-guide/getting-started#installation-and-usage). Ensuite, installez le [plugin](https://www.npmjs.com/package/@aws-appsync/eslint-plugin) dans votre projet à l'aide de votre gestionnaire de packages de projet (par exemple, npm, yarn ou pnpm) :
```
$ npm install @aws-appsync/eslint-plugin
```
Dans votre `.eslintrc.{js,yml,json}` fichier, ajoutez **« plugin : @aws -appsync/base »** ou **« plugin : @aws -appsync/recommended** » à la propriété. `extends` L'extrait ci-dessous est un exemple de `.eslintrc` configuration de base pour : JavaScript
```
{
"extends": ["plugin:@aws-appsync/base"]
}
```
Pour utiliser l'ensemble de règles **« plugin : @aws -appsync/recommended »**, installez la dépendance requise :
```
$ npm install -D @typescript-eslint/parser
```
Créez ensuite un `.eslintrc.js` fichier :
```
{
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaVersion": 2018,
"project": "./tsconfig.json"
},
"extends": ["plugin:@aws-appsync/recommended"]
}
```
# Regroupement et sources TypeScript de cartes pour l'environnement d'exécution `APPSYNC_JS`
TypeScript améliore AWS AppSync le développement en garantissant la sécurité des types et la détection précoce des erreurs. Vous pouvez écrire TypeScript du code localement et le transpiler JavaScript avant de l'utiliser avec le `APPSYNC_JS` moteur d'exécution. Le processus commence par l'installation TypeScript et la configuration de tsconfig.json pour l'environnement. `APPSYNC_JS` Vous pouvez ensuite utiliser des outils de regroupement tels que esbuild pour compiler et regrouper le code. La CLI Amplify générera des types à partir du schéma GraphQL, ce qui vous permettra d'utiliser ces types dans le code du résolveur.
Vous pouvez utiliser des bibliothèques personnalisées et externes dans votre résolveur et votre code de fonction, à condition qu'elles soient conformes aux `APPSYNC_JS` exigences. Les outils de regroupement combinent le code dans un seul fichier à utiliser dans AWS AppSync. Des cartes sources peuvent être incluses pour faciliter le débogage.
## Tirer parti des bibliothèques et regrouper votre code
Dans votre résolveur et votre code de fonction, vous pouvez tirer parti des bibliothèques personnalisées et externes à condition qu'elles soient conformes aux `APPSYNC_JS` exigences. Cela permet de réutiliser le code existant dans votre application. Pour utiliser des bibliothèques définies par plusieurs fichiers, vous devez utiliser un outil de regroupement, tel que [esbuild](https://esbuild.github.io/), pour combiner votre code dans un seul fichier qui peut ensuite être enregistré dans votre AWS AppSync résolveur ou votre fonction.
Lorsque vous regroupez votre code, gardez les points suivants à l'esprit :
+ `APPSYNC_JS`supporte uniquement les ECMAScript modules (ESM).
+ `@aws-appsync/*`les modules sont intégrés dans votre code `APPSYNC_JS` et ne doivent pas être fournis avec celui-ci.
+ L'environnement `APPSYNC_JS` d'exécution est similaire à NodeJS dans la mesure où le code ne s'exécute pas dans un environnement de navigateur.
+ Vous pouvez inclure une carte source facultative. Cependant, n'incluez pas le contenu source.
Pour en savoir plus sur les cartes sources, reportez-vous à la section [Utilisation des cartes sources](#source-maps).
Par exemple, pour regrouper le code de votre résolveur situé à l'adresse`src/appsync/getPost.resolver.js`, vous pouvez utiliser la commande ESbuild CLI suivante :
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/getPost.resolver.js
```
## Création de votre code et utilisation de TypeScript
[TypeScript](https://www.typescriptlang.org/)est un langage de programmation développé par Microsoft qui offre toutes JavaScript les fonctionnalités ainsi que le système de TypeScript saisie. Vous pouvez l'utiliser TypeScript pour écrire du code sécurisé et détecter les erreurs et les bogues au moment de la compilation avant d'enregistrer votre code dans. AWS AppSync Le `@aws-appsync/utils` package est entièrement dactylographié.
Le `APPSYNC_JS` moteur d'exécution ne prend pas TypeScript directement en charge. Vous devez d'abord transpiler votre TypeScript code en JavaScript code compatible avec le `APPSYNC_JS` moteur d'exécution avant de l'enregistrer. AWS AppSync Vous pouvez l'utiliser TypeScript pour écrire votre code dans votre environnement de développement intégré (IDE) local, mais notez que vous ne pouvez pas créer de TypeScript code dans la AWS AppSync console.
Pour commencer, assurez-vous que vous l'avez [TypeScript](https://www.typescriptlang.org/download)installé dans votre projet. Configurez ensuite vos paramètres de TypeScript transcompilation pour qu'ils fonctionnent avec le `APPSYNC_JS` moteur d'exécution à l'aide [TSConfig](https://www.typescriptlang.org/tsconfig)de. Voici un exemple de `tsconfig.json` fichier de base que vous pouvez utiliser :
```
// tsconfig.json
{
"compilerOptions": {
"target": "esnext",
"module": "esnext",
"noEmit": true,
"moduleResolution": "node",
}
}
```
Vous pouvez ensuite utiliser un outil de regroupement comme esbuild pour compiler et regrouper votre code. Par exemple, si votre AWS AppSync code se trouve dans un projet`src/appsync`, vous pouvez utiliser la commande suivante pour compiler et regrouper votre code :
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/**/*.ts
```
### Utilisation du codegen Amplify
Vous pouvez utiliser la [CLI Amplify](https://docs.amplify.aws/cli/) pour générer les types de votre schéma. Dans le répertoire où se trouve votre `schema.graphql` fichier, exécutez la commande suivante et passez en revue les instructions pour configurer votre codegen :
```
$ npx @aws-amplify/cli codegen add
```
Pour régénérer votre codegen dans certaines circonstances (par exemple, lorsque votre schéma est mis à jour), exécutez la commande suivante :
```
$ npx @aws-amplify/cli codegen
```
Vous pouvez ensuite utiliser les types générés dans le code de votre résolveur. Par exemple, selon le schéma suivant :
```
type Todo {
id: ID!
title: String!
description: String
}
type Mutation {
createTodo(title: String!, description: String): Todo
}
type Query {
listTodos: Todo
}
```
Vous pouvez utiliser les types générés dans l'exemple de AWS AppSync fonction suivant :
```
import { Context, util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
import { CreateTodoMutationVariables, Todo } from './API' // codegen
export function request(ctx: Context) {
ctx.args.description = ctx.args.description ?? 'created on ' + util.time.nowISO8601()
return ddb.put({ key: { id: util.autoId() }, item: ctx.args })
}
export function response(ctx) {
return ctx.result as Todo
}
```
### Utilisation de génériques dans TypeScript
Vous pouvez utiliser des génériques avec plusieurs des types fournis. Par exemple, l'extrait ci-dessous est un `Todo` type :
```
export type Todo = {
__typename: "Todo",
id: string,
title: string,
description?: string | null,
};
```
Vous pouvez écrire un résolveur pour un abonnement qui utilise. `Todo` Dans votre IDE, les définitions de type et les conseils de saisie automatique vous aideront à utiliser correctement l'utilitaire de `toSubscriptionFilter` transformation :
```
import { util, Context, extensions } from '@aws-appsync/utils'
import { Todo } from './API'
export function request(ctx: Context) {
return {}
}
export function response(ctx: Context) {
const filter = util.transform.toSubscriptionFilter({
title: { beginsWith: 'hello' },
description: { contains: 'created' },
})
extensions.setSubscriptionFilter(filter)
return null
}
```
## Linting vos paquets
Vous pouvez automatiquement pelucher vos bundles en important le `esbuild-plugin-eslint` plugin. Vous pouvez ensuite l'activer en fournissant une `plugins` valeur qui active les fonctionnalités eslint. Vous trouverez ci-dessous un extrait qui utilise l' JavaScript API esbuild dans un fichier appelé : `build.mjs`
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
## Utilisation de cartes sources
Vous pouvez fournir une carte source en ligne (`sourcemap`) avec votre JavaScript code. Les cartes sources sont utiles lorsque vous regroupez JavaScript ou TypeScript codez et que vous souhaitez voir des références à vos fichiers source d'entrée dans vos journaux et dans vos messages d' JavaScript erreur d'exécution.
Vous `sourcemap` devez apparaître à la fin de votre code. Il est défini par une seule ligne de commentaire qui suit le format suivant :
```
//# sourceMappingURL=data:application/json;base64,
```
Voici un exemple :
```
//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsibGliLmpzIiwgImNvZGUuanMiXSwKICAibWFwcGluZ3MiOiAiO0FBQU8sU0FBUyxRQUFRO0FBQ3RCLFNBQU87QUFDVDs7O0FDRE8sU0FBUyxRQUFRLEtBQUs7QUFDM0IsU0FBTyxNQUFNO0FBQ2Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
```
Les cartes sources peuvent être créées avec esbuild. L'exemple ci-dessous vous montre comment utiliser l' JavaScriptAPI esbuild pour inclure une carte source en ligne lors de la création et du regroupement du code :
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
sourcemap: 'inline',
sourcesContent: false,
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
En particulier, les `sourcesContent` options `sourcemap` et spécifient qu'une carte source doit être ajoutée en ligne à la fin de chaque build, mais ne doit pas inclure le contenu source. Par convention, nous vous recommandons de ne pas inclure de contenu source dans votre`sourcemap`. Vous pouvez le désactiver dans esbuild en réglant `sources-content` sur`false`.
Pour illustrer le fonctionnement des cartes sources, consultez l'exemple suivant dans lequel un code de résolution fait référence à des fonctions d'assistance d'une bibliothèque d'assistance. Le code contient des instructions de journal dans le code du résolveur et dans la bibliothèque d'assistance :
**. /src/default.resolver.ts** (votre résolveur)
```
import { Context } from '@aws-appsync/utils'
import { hello, logit } from './helper'
export function request(ctx: Context) {
console.log('start >')
logit('hello world', 42, true)
console.log('< end')
return 'test'
}
export function response(ctx: Context): boolean {
hello()
return ctx.prev.result
}
```
**.src/helper.ts** (un fichier d'assistance)
```
export const logit = (...rest: any[]) => {
// a special logger
console.log('[logger]', ...rest.map((r) => `<${r}>`))
}
export const hello = () => {
// This just returns a simple sentence, but it could do more.
console.log('i just say hello..')
}
```
Lorsque vous créez et regroupez le fichier de résolution, votre code de résolution inclut une carte source intégrée. Lorsque votre résolveur s'exécute, les entrées suivantes apparaissent dans les CloudWatch journaux :
![\[CloudWatch log entries showing resolver code execution with inline source map information.\]](http://docs.aws.amazon.com/fr_fr/appsync/latest/devguide/images/cloudwatch-sourcemap.jpeg)
En regardant les entrées du CloudWatch journal, vous remarquerez que les fonctionnalités des deux fichiers ont été regroupées et s'exécutent simultanément. Le nom de fichier d'origine de chaque fichier est également clairement reflété dans les journaux.
# Tester votre résolveur et vos gestionnaires de fonctions dans AWS AppSync
Vous pouvez utiliser la commande `EvaluateCode` API pour tester à distance votre résolveur et vos gestionnaires de fonctions avec des données simulées avant d'enregistrer votre code dans un résolveur ou une fonction. Pour commencer à utiliser la commande, assurez-vous d'avoir ajouté l'`appsync:evaluatecode`autorisation à votre politique. Par exemple :
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Vous pouvez utiliser la commande à l'aide de la [AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/index.html) ou [AWS SDKs](https://aws.amazon.com/tools/). Par exemple, pour tester votre code à l'aide de la CLI, il vous suffit de pointer sur votre fichier, de fournir un contexte et de spécifier le gestionnaire que vous souhaitez évaluer :
```
aws appsync evaluate-code \
--code file://code.js \
--function request \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
La réponse contient un `evaluationResult` contenant la charge utile renvoyée par votre gestionnaire. Il contient également un `logs` objet contenant la liste des journaux générés par votre gestionnaire lors de l'évaluation. Cela permet de déboguer facilement l'exécution de votre code et de consulter les informations relatives à votre évaluation pour vous aider à résoudre le problème. Par exemple :
```
{
"evaluationResult": "{\"operation\":\"PutItem\",\"key\":{\"id\":{\"S\":\"record-id\"}},\"attributeValues\":{\"owner\":{\"S\":\"John doe\"},\"expectedVersion\":{\"N\":2},\"authorId\":{\"S\":\"Sammy Davis\"}}}",
"logs": [
"INFO - code.js:5:3: \"current id\" \"record-id\"",
"INFO - code.js:9:3: \"request evaluated\""
]
}
```
Le résultat de l'évaluation peut être analysé au format JSON, ce qui donne :
```
{
"operation": "PutItem",
"key": {
"id": {
"S": "record-id"
}
},
"attributeValues": {
"owner": {
"S": "John doe"
},
"expectedVersion": {
"N": 2
},
"authorId": {
"S": "Sammy Davis"
}
}
}
```
À l'aide du SDK, vous pouvez facilement intégrer des tests issus de votre suite de tests pour valider le comportement de votre code. Notre exemple ici utilise le [Jest Testing Framework](https://jestjs.io/), mais n'importe quelle suite de tests fonctionne. L'extrait suivant montre une exécution de validation hypothétique. Notez que nous nous attendons à ce que la réponse d'évaluation soit un JSON valide. Nous utilisons donc `JSON.parse` pour récupérer le JSON à partir de la réponse sous forme de chaîne :
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Cela donne le résultat suivant :
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
# Migration de VTL vers in JavaScript AWS AppSync
AWS AppSync vous permet d'écrire votre logique métier pour vos résolveurs et fonctions à l'aide de VTL ou. JavaScript Dans les deux langages, vous rédigez une logique qui indique au AWS AppSync service comment interagir avec vos sources de données. Avec VTL, vous écrivez des modèles de mappage qui doivent être évalués en une chaîne codée en JSON valide. Avec JavaScript, vous écrivez des gestionnaires de requêtes et de réponses qui renvoient des objets. Vous ne renvoyez pas de chaîne codée en JSON.
Par exemple, utilisez le modèle de mappage VTL suivant pour obtenir un élément Amazon DynamoDB :
```
{
"operation": "GetItem",
"key": {
"id": $util.dynamodb.toDynamoDBJson($ctx.args.id),
}
}
```
L'utilitaire `$util.dynamodb.toDynamoDBJson` renvoie une chaîne codée en JSON. S'il `$ctx.args.id` est défini sur``, le modèle est évalué en une chaîne codée en JSON valide :
```
{
"operation": "GetItem",
"key": {
"id": {"S": ""},
}
}
```
Lorsque vous travaillez avec JavaScript, vous n'avez pas besoin d'imprimer des chaînes brutes codées en JSON dans votre code, et l'utilisation d'un utilitaire de ce type n'`toDynamoDBJson`est pas nécessaire. Voici un exemple équivalent du modèle de mappage ci-dessus :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: {id: util.dynamodb.toDynamoDB(ctx.args.id)}
};
}
```
Une alternative consiste à utiliser `util.dynamodb.toMapValues` l'approche recommandée pour gérer un objet de valeurs :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
Cela permet d'évaluer :
```
{
"operation": "GetItem",
"key": {
"id": {
"S": ""
}
}
}
```
**Note**
Nous recommandons d'utiliser le module DynamoDB avec les sources de données DynamoDB :
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
ddb.get({ key: { id: ctx.args.id } })
}
```
Autre exemple, prenez le modèle de mappage suivant pour placer un élément dans une source de données Amazon DynamoDB :
```
{
"operation" : "PutItem",
"key" : {
"id": $util.dynamodb.toDynamoDBJson($util.autoId()),
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Lors de son évaluation, cette chaîne de modèle de mappage doit produire une chaîne codée en JSON valide. Lors de l'utilisation JavaScript, votre code renvoie directement l'objet de la requête :
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id = util.autoId(), ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
qui évalue à :
```
{
"operation": "PutItem",
"key": {
"id": { "S": "2bff3f05-ff8c-4ed8-92b4-767e29fc4e63" }
},
"attributeValues": {
"firstname": { "S": "Shaggy" },
"age": { "N": 4 }
}
}
```
**Note**
Nous recommandons d'utiliser le module DynamoDB avec les sources de données DynamoDB :
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const { id = util.autoId(), ...item } = ctx.args
return ddb.put({ key: { id }, item })
}
```
# Choisir entre un accès direct à une source de données ou un proxy via une source de données Lambda
Grâce à AWS AppSync l'`APPSYNC_JS`environnement d'exécution, vous pouvez écrire votre propre code qui implémente votre logique métier personnalisée en utilisant des AWS AppSync fonctions pour accéder à vos sources de données. Cela vous permet d'interagir directement avec des sources de données telles qu'Amazon DynamoDB, Aurora OpenSearch Serverless, Service APIs, HTTP AWS et d'autres services sans avoir à déployer de services ou d'infrastructures informatiques supplémentaires. AWS AppSync facilite également l'interaction avec une AWS Lambda fonction en configurant une source de données Lambda. Les sources de données Lambda vous permettent d'exécuter une logique métier complexe en utilisant l'ensemble complet des fonctionnalités AWS Lambda de résolution d'une requête GraphQL. Dans la plupart des cas, une AWS AppSync fonction directement connectée à sa source de données cible fournira toutes les fonctionnalités dont vous avez besoin. Dans les situations où vous devez implémenter une logique métier complexe qui n'est pas prise en charge par l'`APPSYNC_JS`environnement d'exécution, vous pouvez utiliser une source de données Lambda comme proxy pour interagir avec votre source de données cible.
| | | |
| --- |--- |--- |
| | Intégration directe des sources de données | Source de données Lambda en tant que proxy |
| Cas d'utilisation | AWS AppSync les fonctions interagissent directement avec les sources de données de l'API. | AWS AppSync les fonctions appelées Lambdas interagissent avec les sources de données de l'API. |
| Environnement d’exécution | APPSYNC\$1JS (JavaScript) | Tout environnement d'exécution Lambda pris en charge |
| Taille maximale du code | 32 000 caractères par fonction AWS AppSync | 50 Mo (compressés, pour le téléchargement direct) par Lambda |
| Modules externes | Limité - Fonctionnalités prises en charge par APPSYNC\$1JS uniquement | Oui |
| Appelez n'importe quel AWS service | Oui - Utilisation d'une source de données AWS AppSync HTTP | Oui - Utilisation du AWS SDK |
| Accès à l'en-tête de la demande | Oui | Oui |
| Accès réseau | Non | Oui |
| Accès au système de fichiers | Non | Oui |
| Journalisation et statistiques | Oui | Oui |
| Construisez et testez entièrement dans AppSync | Oui | Non |
| Démarrage à froid | Non | Non - Avec une simultanéité provisionnée |
| Scalabilité automatique | Oui, de manière transparente par AWS AppSync | Oui, tel que configuré dans Lambda |
| Tarification | Sans frais supplémentaires | Facturé pour l'utilisation de Lambda |
AWS AppSync les fonctions qui s'intègrent directement à leur source de données cible sont idéales pour les cas d'utilisation suivants :
+ Interaction avec Amazon DynamoDB, Aurora Serverless et Service OpenSearch
+ Interaction avec le protocole HTTP APIs et transmission des en-têtes entrants
+ Interaction avec AWS les services à l'aide de sources de données HTTP (avec signature AWS AppSync automatique des demandes avec le rôle de source de données fourni)
+ Mise en œuvre du contrôle d'accès avant d'accéder aux sources de données
+ Implémentation du filtrage des données récupérées avant de répondre à une demande
+ Implémentation d'une orchestration simple avec exécution séquentielle de AWS AppSync fonctions dans un pipeline de résolution
+ Contrôle des connexions de mise en cache et d'abonnement dans les requêtes et les mutations.
AWS AppSync les fonctions qui utilisent une source de données Lambda comme proxy sont idéales pour les cas d'utilisation suivants :
+ Utilisation d'un langage autre que JavaScript le langage VTL (Velocity Template Language)
+ Réglage et contrôle du processeur ou de la mémoire pour optimiser les performances
+ Importation de bibliothèques tierces ou demande de fonctionnalités non prises en charge dans `APPSYNC_JS`
+ Effectuer plusieurs demandes réseau and/or pour obtenir l'accès au système de fichiers pour répondre à une requête
+ Requêtes par lots à l'aide de la [configuration par lots.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html)
# AWS AppSync JavaScript référence à l'objet contextuel du résolveur
AWS AppSync définit un ensemble de variables et de fonctions permettant de travailler avec les gestionnaires de demandes et de réponses. Cela facilite les opérations logiques sur les données avec GraphQL. Ce document décrit ces fonctions et fournit des exemples.
## Accès à la variable `context`
L'`context`argument d'un gestionnaire de demandes et de réponses est un objet qui contient toutes les informations contextuelles pour l'invocation de votre résolveur. Elle présente la structure suivante :
```
type Context = {
arguments: any;
args: any;
identity: Identity;
source: any;
error?: {
message: string;
type: string;
};
stash: any;
result: any;
prev: any;
request: Request;
info: Info;
};
```
**Note**
Vous constaterez souvent que l'`context`objet est appelé`ctx`.
Chaque champ de l'`context`objet est défini comme suit :
### Champs de `context`
** `arguments` **
Carte qui contient tous les arguments GraphQL pour ce champ.
** `identity` **
Objet qui contient des informations sur l’appelant. Pour en savoir plus sur la structure de ce champ, consultez [Identité](#aws-appsync-resolver-context-reference-identity-js).
** `source` **
Carte contenant la résolution du champ parent.
** `stash` **
Le stash est un objet mis à disposition dans chaque résolveur et gestionnaire de fonctions. Le même objet de réserve vit après une seule exécution du résolveur. Cela signifie que vous pouvez utiliser le stash pour transmettre des données arbitraires entre les gestionnaires de requêtes et de réponses et entre les fonctions d'un résolveur de pipeline.
Vous ne pouvez pas supprimer ou remplacer l'intégralité de la réserve, mais vous pouvez ajouter, mettre à jour, supprimer et lire les propriétés de la réserve.
Vous pouvez ajouter des objets à la réserve en modifiant l'un des exemples de code ci-dessous :
```
//Example 1
ctx.stash.newItem = { key: "something" }
//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Vous pouvez supprimer des objets de la réserve en modifiant le code ci-dessous :
```
delete ctx.stash.key
```
** `result` **
Un conteneur pour les résultats de ce résolveur. Ce champ n'est disponible que pour les gestionnaires de réponses.
Par exemple, si vous résolvez le `author` champ de la requête suivante :
```
query {
getPost(id: 1234) {
postId
title
content
author {
id
name
}
}
}
```
La `context` variable complète est alors disponible lorsqu'un gestionnaire de réponses est évalué :
```
{
"arguments" : {
id: "1234"
},
"source": {},
"result" : {
"postId": "1234",
"title": "Some title",
"content": "Some content",
"author": {
"id": "5678",
"name": "Author Name"
}
},
"identity" : {
"sourceIp" : ["x.x.x.x"],
"userArn" : "arn:aws:iam::123456789012:user/appsync",
"accountId" : "666666666666",
"user" : "AIDAAAAAAAAAAAAAAAAAA"
}
}
```
** `prev.result` **
Le résultat de toute opération précédente exécutée dans un résolveur de pipeline.
Si l'opération précédente était le gestionnaire de requêtes du résolveur de pipeline, elle `ctx.prev.result` représente le résultat de l'évaluation et est mise à la disposition de la première fonction du pipeline.
Si l'opération précédente était la première fonction, elle `ctx.prev.result` représente le résultat de l'évaluation du gestionnaire de réponse de la première fonction et est mise à la disposition de la deuxième fonction du pipeline.
Si l'opération précédente était la dernière fonction, elle `ctx.prev.result` représente le résultat de l'évaluation de la dernière fonction et est mise à la disposition du gestionnaire de réponses du résolveur de pipeline.
** `info` **
Objet qui contient des informations sur la demande GraphQL. Pour obtenir la structure de ce champ, veuillez consulter [Infos](#aws-appsync-resolver-context-reference-info-js).
### Identity
La section `identity` contient les informations sur l'appelant. La forme de cette section dépend du type d'autorisation de votre AWS AppSync API.
Pour plus d'informations sur les options AWS AppSync de sécurité, consultez la section [Autorisation et authentification](security-authz.md#aws-appsync-security).
** Autorisation `API_KEY`**
Le `identity` champ n'est pas renseigné.
**Autorisation `AWS_LAMBDA`**
`identity`Il a la forme suivante :
```
type AppSyncIdentityLambda = {
resolverContext: any;
};
```
`identity`Il contient la `resolverContext` clé, contenant le même `resolverContext` contenu renvoyé par la fonction Lambda autorisant la demande.
** Autorisation `AWS_IAM`**
`identity`Il a la forme suivante :
```
type AppSyncIdentityIAM = {
accountId: string;
cognitoIdentityPoolId: string;
cognitoIdentityId: string;
sourceIp: string[];
username: string;
userArn: string;
cognitoIdentityAuthType: string;
cognitoIdentityAuthProvider: string;
};
```
** Autorisation `AMAZON_COGNITO_USER_POOLS`**
`identity`Il a la forme suivante :
```
type AppSyncIdentityCognito = {
sourceIp: string[];
username: string;
groups: string[] | null;
sub: string;
issuer: string;
claims: any;
defaultAuthStrategy: string;
};
```
Chaque champ est défini comme suit :
** `accountId` **
L'identifiant du AWS compte de l'appelant.
** `claims` **
Demandes de l'utilisateur.
** `cognitoIdentityAuthType` **
Authentifié ou non authentifié en fonction du type d'identité.
** `cognitoIdentityAuthProvider` **
Liste séparée par des virgules des informations du fournisseur d'identité externe utilisées pour obtenir les informations d'identification utilisées pour signer la demande.
** `cognitoIdentityId` **
L'identifiant Amazon Cognito de l'appelant.
** `cognitoIdentityPoolId` **
L'ID du pool d'identités Amazon Cognito associé à l'appelant.
** `defaultAuthStrategy` **
Stratégie d'autorisation par défaut pour cet appelant (`ALLOW` ou `DENY`).
** `issuer` **
Émetteur du jeton.
** `sourceIp` **
Adresse IP source de l'appelant qui AWS AppSync reçoit. Si la demande n'inclut pas l'`x-forwarded-for`en-tête, la valeur IP source ne contient qu'une seule adresse IP provenant de la connexion TCP. Si la demande inclut un en-tête `x-forwarded-for`, l'adresse IP source est une liste d'adresses IP de l'en-tête `x-forwarded-for` en plus de l'adresse IP de la connexion TCP.
** `sub` **
UUID de l'utilisateur authentifié.
** `user` **
Utilisateur IAM.
** `userArn` **
Le nom de ressource Amazon (ARN) de l'utilisateur IAM.
** `username` **
Nom de l'utilisateur authentifié. En cas d'autorisation `AMAZON_COGNITO_USER_POOLS`, la valeur de *username* est la valeur de l’attribut *cognito:username*. Dans le cas d'`AWS_IAM`une autorisation, la valeur du *nom d'utilisateur* est la valeur de l' AWS utilisateur principal. Si vous utilisez l'autorisation IAM avec des informations d'identification provenant de pools d'identités Amazon Cognito, nous vous recommandons d'utiliser. `cognitoIdentityId`
### En-têtes de demande d'accès
AWS AppSync permet de transmettre des en-têtes personnalisés depuis les clients et d'y accéder dans vos résolveurs GraphQL en utilisant. `ctx.request.headers` Vous pouvez ensuite utiliser les valeurs d'en-tête pour des actions telles que l'insertion de données dans une source de données ou les contrôles d'autorisation. Vous pouvez utiliser un ou plusieurs en-têtes de demande à l'`$curl`aide d'une clé d'API depuis la ligne de commande, comme indiqué dans les exemples suivants :
**Exemple d'en-tête unique**
Supposons que vous définissiez un en-tête `custom` avec la valeur `nadia`, comme suit :
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Il est alors possible d'y accéder avec `ctx.request.headers.custom`. Par exemple, cela peut se trouver dans le code suivant pour DynamoDB :
```
"custom": util.dynamodb.toDynamoDB(ctx.request.headers.custom)
```
**Exemple d'en-tête multiple**
Vous pouvez également transmettre plusieurs en-têtes dans une seule demande et y accéder dans le gestionnaire de résolution. Par exemple, si l'`custom`en-tête est défini avec deux valeurs :
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Vous pouvez ensuite y accéder comme s'il s'agissait d'un tableau : par exemple, `ctx.request.headers.custom[1]`.
**Note**
AWS AppSync n'expose pas l'en-tête du cookie dans`ctx.request.headers`.
### Accédez au nom de domaine personnalisé de la demande
AWS AppSync prend en charge la configuration d'un domaine personnalisé que vous pouvez utiliser pour accéder à votre GraphQL et à vos points de terminaison en temps réel. APIs Lorsque vous faites une demande avec un nom de domaine personnalisé, vous pouvez obtenir le nom de domaine en utilisant`ctx.request.domainName`.
Lorsque vous utilisez le nom de domaine du point de terminaison GraphQL par défaut, la valeur est. `null`
### Info (Infos)
La section `info` contient des informations sur la demande GraphQL. Cette section se présente sous la forme suivante :
```
type Info = {
fieldName: string;
parentTypeName: string;
variables: any;
selectionSetList: string[];
selectionSetGraphQL: string;
};
```
Chaque champ est défini comme suit :
** `fieldName` **
Nom du champ en cours de résolution.
** `parentTypeName` **
Nom du type parent du champ en cours de résolution.
** `variables` **
Carte qui contient toutes les variables transmises dans la demande GraphQL.
** `selectionSetList` **
Représentation sous forme de liste des champs du jeu de sélection GraphQL. Les champs dotés d'un alias sont référencés uniquement par le nom de l'alias, et non par le nom du champ. L'exemple suivant détaille cela.
** `selectionSetGraphQL` **
Représentation sous forme de chaîne du jeu de sélection, formatée en langage SDL GraphQL. Bien que les fragments ne soient pas fusionnés dans le jeu de sélection, les fragments intégrés sont conservés, comme le montre l'exemple suivant.
**Note**
`JSON.stringify`n'inclura pas `selectionSetGraphQL` et `selectionSetList` dans la sérialisation des chaînes. Vous devez référencer ces propriétés directement.
Par exemple, si vous résolvez le champ `getPost` de la requête suivante :
```
query {
getPost(id: $postId) {
postId
title
secondTitle: title
content
author(id: $authorId) {
authorId
name
}
secondAuthor(id: "789") {
authorId
}
... on Post {
inlineFrag: comments: {
id
}
}
... postFrag
}
}
fragment postFrag on Post {
postFrag: comments: {
id
}
}
```
La `ctx.info` variable complète disponible lors du traitement d'un gestionnaire peut alors être :
```
{
"fieldName": "getPost",
"parentTypeName": "Query",
"variables": {
"postId": "123",
"authorId": "456"
},
"selectionSetList": [
"postId",
"title",
"secondTitle"
"content",
"author",
"author/authorId",
"author/name",
"secondAuthor",
"secondAuthor/authorId",
"inlineFragComments",
"inlineFragComments/id",
"postFragComments",
"postFragComments/id"
],
"selectionSetGraphQL": "{\n getPost(id: $postId) {\n postId\n title\n secondTitle: title\n content\n author(id: $authorId) {\n authorId\n name\n }\n secondAuthor(id: \"789\") {\n authorId\n }\n ... on Post {\n inlineFrag: comments {\n id\n }\n }\n ... postFrag\n }\n}"
}
```
`selectionSetList`n'expose que les champs appartenant au type actuel. Si le type actuel est une interface ou une union, seuls les champs sélectionnés appartenant à l'interface sont exposés. Par exemple, selon le schéma suivant :
```
type Query {
node(id: ID!): Node
}
interface Node {
id: ID
}
type Post implements Node {
id: ID
title: String
author: String
}
type Blog implements Node {
id: ID
title: String
category: String
}
```
Et la requête suivante :
```
query {
node(id: "post1") {
id
... on Post {
title
}
... on Blog {
title
}
}
}
```
Lors de l'appel `ctx.info.selectionSetList` à la résolution du `Query.node` champ, seul `id` est exposé :
```
"selectionSetList": [
"id"
]
```
# 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(