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-js"></a>

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 **transmettra** simplement le résultat du gestionnaire de demandes au gestionnaire de réponses. La résolution du champ ne quitte pas AWS AppSync.

Les résolveurs locaux sont utiles dans de nombreuses situations. 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, créons une application pub/sub dans laquelle les utilisateurs peuvent publier des messages et s'y abonner. 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 pub/sub
<a name="create-the-pub-sub-application-js"></a>

Créez d'abord une API GraphQL vierge en choisissant l'option **Design from scratch** et en configurant les détails facultatifs lors de la création de votre API GraphQL.

Dans notre application pub/sub, les clients peuvent s'abonner à des messages et les publier. Chaque message publié inclut un nom et des données. Ajoutez ceci au schéma :

```
type Channel {
	name: String!
	data: AWSJSON!
}

type Mutation {
	publish(name: String!, data: AWSJSON!): Channel
}

type Query {
	getChannel: Channel
}

type Subscription {
	subscribe(name: String!): Channel
		@aws_subscribe(mutations: ["publish"])
}
```

Attachons ensuite un résolveur au `Mutation.publish` champ. Dans le volet **Résolveurs** situé à côté du volet **Schéma**, recherchez le `Mutation` type, puis le `publish(...): Channel` champ, puis cliquez sur **Joindre**.

Créez une source de données *None* et nommez-la *PageDataSource*. Attachez-le à votre résolveur.

Ajoutez votre implémentation de résolveur à l'aide de l'extrait suivant :

```
export function request(ctx) {
  return { payload: ctx.args };
}

export function response(ctx) {
  return ctx.result;
}
```

Assurez-vous de créer le résolveur et d'enregistrer les modifications que vous avez apportées.

## Envoyer des messages et s'y abonner
<a name="send-and-subscribe-to-messages-js"></a>

Pour que les clients puissent recevoir des messages, ils doivent d'abord être abonnés à une boîte de réception.

Dans le volet **Requêtes**, exécutez l'`SubscribeToData`abonnement :

```
subscription SubscribeToData {
    subscribe(name:"channel") {
        name
        data
    }
}
```

 L'abonné recevra des messages chaque fois que la `publish` mutation est invoquée, mais uniquement lorsque le message est envoyé à l'`channel`abonnement. Essayons cela dans le volet **Requêtes**. Pendant que votre abonnement est toujours en cours d'exécution dans la console, ouvrez une autre console et exécutez la requête suivante dans le volet **Requêtes** :

**Note**  
Nous utilisons des chaînes JSON valides dans cet exemple.

```
mutation PublishData {
    publish(data: "{\"msg\": \"hello world!\"}", name: "channel") {
        data
        name
    }
}
```

Le résultat doit se présenter comme suit :

```
{
  "data": {
    "publish": {
      "data": "{\"msg\":\"hello world!\"}",
      "name": "channel"
    }
  }
}
```

Nous venons de démontrer l'utilisation de résolveurs locaux, en publiant un message et en le recevant sans quitter le AWS AppSync service.