Utilisation de résolveurs locaux dans AWS AppSync

Note

Nous prenons désormais principalement en charge le runtime APPSYNC _JS et sa documentation. Pensez à utiliser le runtime APPSYNC _JS et ses guides ici.

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.

Création de l'application de pagination

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 !

Envoi et abonnement aux pages

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 de démontrer l'utilisation de résolveurs locaux, en envoyant une page et en la recevant sans la quitter AWS AppSync.