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.

# Utilisation de résolveurs locaux dans AWS AppSync
<a name="tutorial-local-resolvers"></a>

**Note**  
Nous prenons désormais principalement en charge le runtime APPSYNC\$1JS et sa documentation. [Pensez à utiliser le runtime APPSYNC\$1JS et ses guides ici.](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html)

AWS AppSync vous permet d'utiliser des sources de données prises en charge (AWS Lambda Amazon DynamoDB ou OpenSearch Amazon Service) pour effectuer diverses opérations. Cependant, dans certains cas, un appel à une source de données prise en charge peut ne pas être nécessaire.

C'est là où le résolveur local se révèle pratique. Au lieu d'appeler une source de données distante, le résolveur local **achemine** simplement le résultat du modèle de mappage de la demande vers le modèle de mappage de la réponse. La résolution du champ ne quitte pas AWS AppSync.

Les résolveurs locaux sont utiles dans plusieurs scénarios. Le scénario le plus répandu consiste à publier des notifications sans déclencher d'appel de source de données. Pour illustrer ce cas d'utilisation, nous allons créer une application de pagination, où les utilisateurs peuvent paginer entre eux. Comme cet exemple met à profit les *Abonnements*, si vous n'êtes pas familiarisé avec les *Abonnements*, vous pouvez suivre le didacticiel [Données en temps réel](aws-appsync-real-time-data.md).

## Création de l'application de pagination
<a name="create-the-paging-application"></a>

Dans notre application de pagination, les clients peuvent s'abonner à une boîte de réception et envoyer des pages à d'autres clients. Chaque page comprend un message. Voici le schéma :

```
schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
}

type Subscription {
    inbox(to: String!): Page
    @aws_subscribe(mutations: ["page"])
}

type Mutation {
    page(body: String!, to: String!): Page!
}

type Page {
    from: String
    to: String!
    body: String!
    sentAt: String!
}

type Query {
    me: String
}
```

Attachons un résolveur au champ `Mutation.page`. Dans le volet **Schema (Schéma)**, cliquez sur *Attach Resolver (Attacher un résolveur)* en regard de la définition du champ sur le volet droit. Créez une nouvelle source de données de type *None* et nommez-la *PageDataSource*.

Pour le modèle de mappage de la demande, saisissez :

```
{
  "version": "2017-02-28",
  "payload": {
    "body": $util.toJson($context.arguments.body),
    "from": $util.toJson($context.identity.username),
    "to":  $util.toJson($context.arguments.to),
    "sentAt": "$util.time.nowISO8601()"
  }
}
```

Et pour le modèle de mappage de la réponse, sélectionnez la valeur par défaut *Forward the result (Transmettre le résultat)*. Enregistrez votre résolveur. Votre application est désormais prête, commençons à paginer \$1

## Envoi et abonnement aux pages
<a name="send-and-subscribe-to-pages"></a>

Pour que les clients reçoivent des pages, ils doivent d'abord s'abonner à une boîte de réception.

Dans le volet **Requêtes**, exécutons l'abonnement `inbox` :

```
subscription Inbox {
    inbox(to: "Nadia") {
        body
        to
        from
        sentAt
    }
}
```

 *Nadia* recevra les pages chaque fois que la mutation `Mutation.page` est appelée. Appelons la mutation en l'exécutant :

```
mutation Page {
    page(to: "Nadia", body: "Hello, World!") {
        body
        to
        from
        sentAt
    }
}
```

Nous venons juste d'illustrer l'utilisation des résolveurs locaux, en envoyant une page et en la recevant sans quitter AWS AppSync.