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.
# Création de requêtes de base (JavaScript)
Les résolveurs GraphQL connectent les champs d'un schéma de type à une source de données. Les résolveurs sont le mécanisme par lequel les demandes sont satisfaites.
Résolveurs AWS AppSync utilisés JavaScript pour convertir une expression GraphQL dans un format utilisable par la source de données. Les modèles de mappage peuvent également être écrits dans le [langage VTL (Apache Velocity Template Language)](https://velocity.apache.org/engine/2.0/vtl-reference.html) pour convertir une expression GraphQL dans un format utilisable par la source de données.
Cette section décrit comment configurer les résolveurs à l'aide JavaScript de. La section [Tutoriels sur les résolveurs (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) propose des didacticiels approfondis sur la façon d'implémenter des résolveurs à l'aide de. JavaScript La section [Resolver reference (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) fournit une explication des opérations utilitaires qui peuvent être utilisées avec les JavaScript résolveurs.
Nous vous recommandons de suivre ce guide avant d'essayer d'utiliser l'un des didacticiels mentionnés ci-dessus.
Dans cette section, nous expliquerons comment créer et configurer des résolveurs pour les requêtes et les mutations.
**Note**
Ce guide part du principe que vous avez créé votre schéma et que vous avez au moins une requête ou une mutation. Si vous recherchez des abonnements (données en temps réel), consultez [ce](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html) guide.
Dans cette section, nous allons fournir quelques étapes générales pour configurer les résolveurs, ainsi qu'un exemple utilisant le schéma ci-dessous :
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Création de résolveurs de requêtes de base
Cette section explique comment créer un résolveur de requêtes de base.
------
#### [ Console ]
1. Connectez-vous à la [AppSyncconsole AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Entrez les détails de votre schéma et de votre source de données. Consultez les sections [Conception de votre schéma](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) et [Attachement d'une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) pour plus d'informations.
1. À côté de l'éditeur de **schéma**, il y a une fenêtre appelée **Resolvers.** Cette zone contient une liste des types et des champs tels que définis dans votre fenêtre de **schéma**. Vous pouvez associer des résolveurs aux champs. Vous allez probablement associer des résolveurs à vos opérations sur le terrain. Dans cette section, nous allons examiner les configurations de requêtes simples. Sous le type de **requête**, choisissez **Joindre** à côté du champ de votre requête.
1. Sur la page **Attacher un résolveur**, sous **Type de résolveur**, vous pouvez choisir entre des résolveurs de type pipeline ou unitaire. Pour plus d'informations sur ces types, consultez la section [Résolveurs.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Ce guide utilisera`pipeline resolvers`.
**Astuce**
Lorsque vous créez des résolveurs de pipeline, vos sources de données seront associées aux fonctions de pipeline. Les fonctions sont créées une fois que vous avez créé le résolveur de pipeline lui-même, c'est pourquoi il n'est pas possible de le définir dans cette page. Si vous utilisez un résolveur d'unités, la source de données est directement liée au résolveur. Vous devez donc la définir dans cette page.
Pour **Resolver Runtime**, choisissez `APPSYNC_JS` d'activer le JavaScript runtime.
1. Vous pouvez activer la [mise en cache](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) pour cette API. Nous vous recommandons de désactiver cette fonctionnalité pour le moment. Choisissez **Créer**.
1. Sur la page **Modifier le résolveur**, il existe un éditeur de code appelé **Resolver code** qui vous permet d'implémenter la logique du gestionnaire de résolution et de la réponse (avant et après les étapes). Pour plus d'informations, consultez la [présentation des JavaScript résolveurs](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
**Note**
Dans notre exemple, nous allons simplement laisser la demande vide et la réponse définie pour renvoyer le dernier résultat de la source de données à partir du [contexte](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) :
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Sous cette section, il y a un tableau appelé **Fonctions**. Les fonctions vous permettent d'implémenter du code qui peut être réutilisé dans plusieurs résolveurs. Au lieu de constamment réécrire ou copier le code, vous pouvez stocker le code source sous forme de fonction à ajouter à un résolveur chaque fois que vous en avez besoin.
Les fonctions constituent l'essentiel de la liste des opérations d'un pipeline. Lorsque vous utilisez plusieurs fonctions dans un résolveur, vous définissez l'ordre des fonctions, et elles seront exécutées dans cet ordre de manière séquentielle. Ils sont exécutés après l'exécution de la fonction de demande et avant le début de la fonction de réponse.
Pour ajouter une nouvelle fonction, sous **Fonctions**, choisissez **Ajouter une fonction**, puis **Créer une nouvelle fonction**. Vous pouvez également voir un bouton **Créer une fonction** pour choisir à la place.
1. Choisissez une source de données. Il s'agira de la source de données sur laquelle le résolveur agira.
**Note**
Dans notre exemple, nous attachons un résolveur pour`getPost`, qui récupère un `Post` objet par. `id` Supposons que nous ayons déjà configuré une table DynamoDB pour ce schéma. Sa clé de partition est définie sur `id` et est vide.
1. Entrez un`Function name`.
1. Sous **Code de fonction**, vous devez implémenter le comportement de la fonction. Cela peut prêter à confusion, mais chaque fonction aura son propre gestionnaire de requêtes et de réponses local. La demande est exécutée, puis la source de données est invoquée pour traiter la demande, puis la réponse de la source de données est traitée par le gestionnaire de réponses. Le résultat est stocké dans l'objet de [contexte](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html). Ensuite, la fonction suivante de la liste s'exécutera ou sera transmise au gestionnaire de réponses après étape s'il s'agit de la dernière.
**Note**
Dans notre exemple, nous attachons un résolveur à`getPost`, qui obtient une liste d'`Post`objets à partir de la source de données. Notre fonction de requête demandera les données de notre table, la table transmettra sa réponse au contexte (ctx), puis la réponse renverra le résultat dans le contexte. AWS AppSync Sa force réside dans son interconnexion avec les autres AWS services. Comme nous utilisons DynamoDB, nous disposons d'[une suite d'opérations pour simplifier ce type de](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) choses. Nous avons également quelques exemples standard pour d'autres types de sources de données.
Notre code ressemblera à ceci :
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Au cours de cette étape, nous avons ajouté deux fonctions :
`request`: Le gestionnaire de demandes effectue l'opération de récupération par rapport à la source de données. L'argument contient l'objet contextuel (`ctx`) ou certaines données accessibles à tous les résolveurs effectuant une opération particulière. Par exemple, il peut contenir des données d'autorisation, les noms de champs en cours de résolution, etc. L'instruction return exécute une [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)opération (voir [ici](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) pour des exemples). Comme nous travaillons avec DynamoDB, nous sommes autorisés à utiliser certaines des opérations de ce service. L'analyse effectue une extraction de base de tous les éléments de notre tableau. Le résultat de cette opération est stocké dans l'objet de contexte sous forme de `result` conteneur avant d'être transmis au gestionnaire de réponses. Le `request` est exécuté avant la réponse dans le pipeline.
`response`: le gestionnaire de réponses qui renvoie le résultat du`request`. L'argument est l'objet de contexte mis à jour et l'instruction de retour est`ctx.prev.result`. À ce stade du guide, cette valeur ne vous est peut-être pas familière. `ctx`fait référence à l'objet de contexte. `prev`fait référence à l'opération précédente dans le pipeline, qui était la nôtre`request`. `result`Il contient le ou les résultats du résolveur lorsqu'il se déplace dans le pipeline. Si vous mettez le tout ensemble, `ctx.prev.result` il renvoie le résultat de la dernière opération effectuée, à savoir le gestionnaire de demandes.
1. Choisissez **Créer une** fois que vous avez terminé.
1. De retour sur l'écran du résolveur, sous **Fonctions**, choisissez le menu déroulant **Ajouter une fonction** et ajoutez votre fonction à votre liste de fonctions.
1. Choisissez **Enregistrer** pour mettre à jour le résolveur.
------
#### [ CLI ]
**Pour ajouter votre fonction**
+ Créez une fonction pour votre résolveur de pipeline à l'aide de la `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)` commande.
Vous devez entrer quelques paramètres pour cette commande en particulier :
1. Celui `api-id` de votre API.
1. Le `name` de la fonction dans la AWS AppSync console.
1. Le `data-source-name` ou le nom de la source de données que la fonction utilisera. Il doit déjà être créé et lié à votre API GraphQL dans le AWS AppSync service.
1. L'`runtime`environnement ou le langage de la fonction. Car JavaScript le nom doit être`APPSYNC_JS`, et le runtime,`1.0.0`.
1. Les `code` gestionnaires de requêtes et de réponses de votre fonction. Bien que vous puissiez le saisir manuellement, il est beaucoup plus facile de l'ajouter à un fichier .txt (ou dans un format similaire), puis de le transmettre en tant qu'argument.
**Note**
Notre code de requête se trouvera dans un fichier transmis en argument :
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Voici un exemple de commande :
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**Note**
Assurez-vous de l'enregistrer `functionId` quelque part car cela sera utilisé pour associer la fonction au résolveur.
**Pour créer votre résolveur**
+ Créez une fonction de pipeline pour `Query` en exécutant la `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` commande.
Vous devez entrer quelques paramètres pour cette commande en particulier :
1. Celui `api-id` de votre API.
1. Le `type-name` ou le type d'objet spécial dans votre schéma (requête, mutation, abonnement).
1. L'`field-name`opération ou l'opération sur le terrain à l'intérieur du type d'objet spécial auquel vous souhaitez associer le résolveur.
1. Le`kind`, qui spécifie un résolveur d'unité ou de pipeline. Définissez ce paramètre sur `PIPELINE` pour activer les fonctions de pipeline.
1. La `pipeline-config` ou les fonctions à associer au résolveur. Assurez-vous de connaître les `functionId` valeurs de vos fonctions. L'ordre d'inscription est important.
1. Le`runtime`, qui était `APPSYNC_JS` (JavaScript). L'est `runtimeVersion` actuellement`1.0.0`.
1. Le`code`, qui contient les gestionnaires d'étapes avant et après.
**Note**
Notre code de requête se trouvera dans un fichier transmis en argument :
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Voici un exemple de commande :
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Astuce**
Avant d'utiliser le CDK, nous vous recommandons de consulter la [documentation officielle du CDK ainsi que la](https://docs.aws.amazon.com/cdk/v2/guide/home.html) référence AWS AppSync du [CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
Les étapes répertoriées ci-dessous ne montreront qu'un exemple général de l'extrait de code utilisé pour ajouter une ressource particulière. Cela **n'est pas** censé être une solution fonctionnelle dans votre code de production. Nous partons également du principe que vous disposez déjà d'une application fonctionnelle.
Une application de base nécessite les éléments suivants :
1. Directives d'importation de services
1. Code de schéma
1. Générateur de sources de données
1. Code de fonction
1. Code du résolveur
Dans les sections [Conception de votre schéma](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) et [Attachement d'une source de données](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), nous savons que le fichier de pile inclura les directives d'importation du formulaire :
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**Note**
Dans les sections précédentes, nous avons uniquement indiqué comment importer des AWS AppSync constructions. Dans le code réel, vous devrez importer davantage de services juste pour exécuter l'application. Dans notre exemple, si nous devions créer une application CDK très simple, nous importerions au moins le AWS AppSync service avec notre source de données, qui était une table DynamoDB. Nous aurions également besoin d'importer des constructions supplémentaires pour déployer l'application :
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Pour résumer chacune d'entre elles :
`import * as cdk from 'aws-cdk-lib';`: Cela vous permet de définir votre application CDK et des constructions telles que la pile. Il contient également des fonctions utilitaires utiles pour notre application, telles que la manipulation des métadonnées. Si vous connaissez cette directive d'importation, mais que vous vous demandez pourquoi la bibliothèque principale cdk n'est pas utilisée ici, consultez la page de [migration](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: Cela permet d'importer le [AWS AppSync service](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: Ceci importe le service [DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`: Nous en avons besoin pour définir la [construction](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html) racine.
Le type d'importation dépend des services que vous appelez. Nous vous recommandons de consulter la documentation du CDK pour obtenir des exemples. Le schéma en haut de la page sera un fichier distinct dans votre application CDK sous forme de `.graphql` fichier. Dans le fichier de pile, nous pouvons l'associer à un nouveau GraphQL sous la forme :
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**Note**
Dans le cadre de `add_api` ce projet, nous ajoutons une nouvelle API GraphQL en utilisant le `new` mot clé suivi de. `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` Notre champ d'application est `this` le suivant : l'identifiant CFN est`graphQL-example`, et nos accessoires sont `my-first-api` (nom de l'API dans la console) et `schema.graphql` (le chemin absolu vers le fichier de schéma).
Pour ajouter une source de données, vous devez d'abord ajouter votre source de données à la pile. Ensuite, vous devez l'associer à l'API GraphQL en utilisant la méthode spécifique à la source. L'association se produira lorsque vous ferez fonctionner votre résolveur. En attendant, prenons un exemple en créant la table DynamoDB en utilisant : `dynamodb.Table`
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**Note**
Si nous devions l'utiliser dans notre exemple, nous ajouterions une nouvelle table DynamoDB avec l'identifiant CFN de et une clé `posts-table` de partition de. `id (S)`
Ensuite, nous devons implémenter notre résolveur dans le fichier de pile. Voici un exemple de requête simple qui recherche tous les éléments d'une table DynamoDB :
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**Note**
Tout d'abord, nous avons créé une fonction appelée`add_func`. Cet ordre de création peut sembler un peu paradoxal, mais vous devez créer les fonctions dans votre résolveur de pipeline avant de créer le résolveur lui-même. Une fonction se présente sous la forme suivante :
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Notre champ d'application était`this`, notre identifiant CFN l'était`func-get-posts`, et nos accessoires contenaient les détails de la fonction réelle. À l'intérieur des accessoires, nous avons inclus :
La `name` fonction qui sera présente dans la AWS AppSync console (`get_posts_func_1`).
L'API GraphQL que nous avons créée précédemment ()`add_api`.
La source de données ; c'est le point où nous lions la source de données à la valeur de l'API GraphQL, puis nous l'associons à la fonction. Nous prenons la table que nous avons créée (`add_ddb_table`) et l'attachons à l'API GraphQL (`add_api`) en utilisant l'une des `GraphqlApi` méthodes ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)). La valeur id (`table-for-posts`) est le nom de la source de données dans la AWS AppSync console. Pour obtenir la liste des méthodes spécifiques à la source, consultez les pages suivantes :
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
Le code contient les gestionnaires de demandes et de réponses de notre fonction, à savoir un simple scan et un retour.
Le runtime indique que nous voulons utiliser le runtime APPSYNC\$1JS version 1.0.0. Notez qu'il s'agit actuellement de la seule version disponible pour APPSYNC\$1JS.
Ensuite, nous devons associer la fonction au résolveur de pipeline. Nous avons créé notre résolveur en utilisant le formulaire :
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Notre champ d'application était`this`, notre identifiant CFN l'était`pipeline-resolver-get-posts`, et nos accessoires contenaient les détails de la fonction réelle. À l'intérieur des accessoires, nous avons inclus :
L'API GraphQL que nous avons créée précédemment ()`add_api`.
Le nom du type d'objet spécial ; il s'agit d'une opération de requête, nous avons donc simplement ajouté la valeur`Query`.
Le nom du champ (`getPost`) est le nom du champ dans le schéma sous le `Query` type.
Le code contient vos gestionnaires avant et après. Notre exemple renvoie simplement les résultats qui se trouvaient dans le contexte une fois que la fonction a effectué son opération.
Le runtime indique que nous voulons utiliser le runtime APPSYNC\$1JS version 1.0.0. Notez qu'il s'agit actuellement de la seule version disponible pour APPSYNC\$1JS.
La configuration du pipeline contient la référence à la fonction que nous avons créée (`add_func`).
------
Pour résumer ce qui s'est passé dans cet exemple, vous avez vu une AWS AppSync fonction implémentant un gestionnaire de requêtes et de réponses. La fonction était chargée d'interagir avec votre source de données. Le gestionnaire de demandes a envoyé une `Scan` opération à AWS AppSync, lui indiquant quelle opération effectuer sur votre source de données DynamoDB. Le gestionnaire de réponses a renvoyé la liste des éléments (`ctx.result.items`). La liste des éléments a ensuite été automatiquement mappée au type `Post` GraphQL.
## Création de résolveurs de mutations de base
Cette section vous montrera comment créer un résolveur de mutations de base.
------
#### [ Console ]
1. Connectez-vous à la [AppSyncconsole AWS Management Console et ouvrez-la](https://console.aws.amazon.com/appsync/).
1. Dans le **APIs tableau de bord**, choisissez votre API GraphQL.
1. Dans la **barre latérale**, choisissez **Schema.**
1. Dans la section **Résolveurs** et dans le type de **mutation**, choisissez **Attacher** à côté de votre champ.
**Note**
Dans notre exemple, nous attachons un résolveur pour`createPost`, qui ajoute un `Post` objet à notre tableau. Supposons que nous utilisions la même table DynamoDB que celle de la section précédente. Sa clé de partition est définie sur `id` et est vide.
1. Sur la page **Joindre un résolveur**, sous **Type de résolveur, sélectionnez**. `pipeline resolvers` Pour rappel, vous trouverez plus d'informations sur les résolveurs [ici](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Pour **Resolver Runtime**, choisissez `APPSYNC_JS` d'activer le JavaScript runtime.
1. Vous pouvez activer la [mise en cache](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) pour cette API. Nous vous recommandons de désactiver cette fonctionnalité pour le moment. Choisissez **Créer**.
1. Choisissez **Ajouter une fonction**, puis **Créer une nouvelle fonction**. Vous pouvez également voir un bouton **Créer une fonction** pour choisir à la place.
1. Choisissez votre source de données . Il doit s'agir de la source dont vous allez manipuler les données avec la mutation.
1. Entrez un`Function name`.
1. Sous **Code de fonction**, vous devez implémenter le comportement de la fonction. Comme il s'agit d'une mutation, la demande effectuera idéalement une opération de changement d'état sur la source de données invoquée. Le résultat sera traité par la fonction de réponse.
**Note**
`createPost`c'est ajouter, ou « mettre », un nouveau `Post` dans le tableau avec nos paramètres comme données. Nous pourrions ajouter quelque chose comme ceci :
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Au cours de cette étape, nous avons également ajouté `request` des `response` fonctionnalités :
`request`: Le gestionnaire de requêtes accepte le contexte comme argument. L'instruction return du gestionnaire de requêtes exécute une [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)commande, qui est une opération DynamoDB intégrée ([voir](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) ici [ou](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) ici pour des exemples). La `PutItem` commande ajoute un `Post` objet à notre table DynamoDB en prenant la valeur de la `key` partition (générée automatiquement `util.autoid()` par) `attributes` et à partir de l'argument de contexte saisi (ce sont les valeurs que nous transmettrons dans notre demande). Les arguments du `title` champ `key` est `id` `date` et `attributes` sont le et. Ils sont tous deux préformatés via l'[https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)assistant pour fonctionner avec la table DynamoDB.
`response`: La réponse accepte le contexte mis à jour et renvoie le résultat du gestionnaire de demandes.
1. Choisissez **Créer une** fois que vous avez terminé.
1. De retour sur l'écran du résolveur, sous **Fonctions**, choisissez le menu déroulant **Ajouter une fonction** et ajoutez votre fonction à votre liste de fonctions.
1. Choisissez **Enregistrer** pour mettre à jour le résolveur.
------
#### [ CLI ]
**Pour ajouter votre fonction**
+ Créez une fonction pour votre résolveur de pipeline à l'aide de la `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)` commande.
Vous devez entrer quelques paramètres pour cette commande en particulier :
1. Celui `api-id` de votre API.
1. Le `name` de la fonction dans la AWS AppSync console.
1. Le `data-source-name` ou le nom de la source de données que la fonction utilisera. Il doit déjà être créé et lié à votre API GraphQL dans le AWS AppSync service.
1. L'`runtime`environnement ou le langage de la fonction. Car JavaScript le nom doit être`APPSYNC_JS`, et le runtime,`1.0.0`.
1. Les `code` gestionnaires de requêtes et de réponses de votre fonction. Bien que vous puissiez le saisir manuellement, il est beaucoup plus facile de l'ajouter à un fichier .txt (ou dans un format similaire) puis de le transmettre comme argument.
**Note**
Notre code de requête se trouvera dans un fichier transmis en argument :
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Voici un exemple de commande :
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**Note**
Assurez-vous de l'enregistrer `functionId` quelque part car cela sera utilisé pour associer la fonction au résolveur.
**Pour créer votre résolveur**
+ Créez une fonction de pipeline pour `Mutation` en exécutant la `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)` commande.
Vous devez entrer quelques paramètres pour cette commande en particulier :
1. Celui `api-id` de votre API.
1. Le `type-name` ou le type d'objet spécial dans votre schéma (requête, mutation, abonnement).
1. L'`field-name`opération ou l'opération sur le terrain à l'intérieur du type d'objet spécial auquel vous souhaitez associer le résolveur.
1. Le`kind`, qui spécifie un résolveur d'unité ou de pipeline. Définissez ce paramètre sur `PIPELINE` pour activer les fonctions de pipeline.
1. La `pipeline-config` ou les fonctions à associer au résolveur. Assurez-vous de connaître les `functionId` valeurs de vos fonctions. L'ordre d'inscription est important.
1. Le`runtime`, qui était `APPSYNC_JS` (JavaScript). L'est `runtimeVersion` actuellement`1.0.0`.
1. Le`code`, qui contient les étapes avant et après.
**Note**
Notre code de requête se trouvera dans un fichier transmis en argument :
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Voici un exemple de commande :
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Une sortie sera renvoyée dans la CLI. Voici un exemple :
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Astuce**
Avant d'utiliser le CDK, nous vous recommandons de consulter la [documentation officielle du CDK ainsi que la](https://docs.aws.amazon.com/cdk/v2/guide/home.html) référence AWS AppSync du [CDK](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
Les étapes répertoriées ci-dessous ne montreront qu'un exemple général de l'extrait de code utilisé pour ajouter une ressource particulière. Cela **n'est pas** censé être une solution fonctionnelle dans votre code de production. Nous partons également du principe que vous disposez déjà d'une application fonctionnelle.
+ Pour effectuer une mutation, en supposant que vous participez au même projet, vous pouvez l'ajouter au fichier de pile comme dans la requête. Voici une fonction modifiée et un résolveur pour une mutation qui ajoute un nouveau élément `Post` à la table :
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**Note**
Comme cette mutation et la requête sont structurées de la même manière, nous allons simplement expliquer les modifications que nous avons apportées pour effectuer la mutation.
Dans la fonction, nous avons changé l'identifiant CFN `func-add-post` et le nom `add_posts_func_1` pour refléter le fait que nous ajoutons `Posts` à la table. Dans la source de données, nous avons créé une nouvelle association avec notre table (`add_ddb_table`) dans la AWS AppSync console, `table-for-posts-2` car la `addDynamoDbDataSource` méthode l'exige. N'oubliez pas que cette nouvelle association utilise toujours la même table que celle que nous avons créée précédemment, mais que nous disposons désormais de deux connexions dans la AWS AppSync console : une pour la requête as `table-for-posts` et une pour la mutation as`table-for-posts-2`. Le code a été modifié pour ajouter un `Post` en générant sa `id` valeur automatiquement et en acceptant les entrées d'un client pour le reste des champs.
Dans le résolveur, nous avons modifié la valeur de l'identifiant `pipeline-resolver-create-posts` pour refléter le fait que nous ajoutons `Posts` à la table. Pour refléter la mutation dans le schéma, le nom du type a été changé en`Mutation`, et le nom,`createPost`. La configuration du pipeline a été définie sur notre nouvelle fonction de mutation`add_func_2`.
------
Pour résumer ce qui se passe dans cet exemple, convertit AWS AppSync automatiquement les arguments définis dans le `createPost` champ à partir de votre schéma GraphQL en opérations DynamoDB. L'exemple stocke les enregistrements dans DynamoDB à l'aide d'une clé `id` de, qui est automatiquement créée à l'aide de notre assistant. `util.autoId()` Tous les autres champs que vous transmettez aux arguments de contexte (`ctx.args.input`) à partir de requêtes effectuées dans la AWS AppSync console ou autrement seront stockés en tant qu'attributs de la table. La clé et les attributs sont automatiquement mappés dans un format DynamoDB compatible à l'aide de l'assistant. `util.dynamodb.toMapValues(values)`
AWS AppSync prend également en charge les flux de travail de test et de débogage pour l'édition de résolveurs. Vous pouvez utiliser un `context` objet fictif pour voir la valeur transformée du modèle avant de l'invoquer. Vous pouvez éventuellement consulter la demande complète adressée à une source de données de manière interactive lorsque vous exécutez une requête. Pour plus d'informations, voir [Tester et déboguer les résolveurs (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) et [Surveillance et journalisation](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring).
## Résolveurs avancés
Si vous suivez la section facultative de pagination de la section [Conception de votre schéma](designing-your-schema.md#aws-appsync-designing-your-schema), vous devez tout de même ajouter votre résolveur à votre demande pour utiliser la pagination. Notre exemple a utilisé une pagination de requête appelée `getPosts` pour renvoyer uniquement une partie des éléments demandés à la fois. Le code de notre résolveur sur ce champ peut ressembler à ceci :
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Dans la demande, nous transmettons le contexte de la demande. Notre `limit` est*20*, ce qui signifie que nous renvoyons jusqu'à 20 `Posts` dans la première requête. Notre `nextToken` curseur est fixé sur la première `Post` entrée de la source de données. Ils sont transmis aux arguments. La demande effectue ensuite un scan depuis le premier `Post` jusqu'au nombre limite de scan. La source de données stocke le résultat dans le contexte, qui est transmis à la réponse. La réponse renvoie `Posts` le résultat récupéré, puis définit le `nextToken` is set sur l'`Post`entrée juste après la limite. La demande suivante est envoyée pour faire exactement la même chose, mais en commençant par le décalage juste après la première requête. N'oubliez pas que ces types de demandes sont effectués de manière séquentielle et non en parallèle.