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.

# Exemple de résolveur de pipeline avec Amazon DynamoDB
<a name="writing-code"></a>

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": "<long story>"
  }
}
```

Enfin, le gestionnaire de réponses du résolveur renvoie directement le résultat.

## Travailler avec des erreurs
<a name="working-with-errors"></a>

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