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.

Configuration et utilisation des résolveurs de pipeline dans AWS AppSync () VTL

AWS AppSync exécute des résolveurs sur un champ GraphQL. Dans certains cas, les applications nécessitent l'exécution de plusieurs opérations pour résoudre un seul champ GraphQL. Avec les résolveurs de pipeline, les développeurs peuvent désormais composer des opérations appelées fonctions et les exécuter en séquence. Les résolveurs de pipeline sont utiles pour les applications qui, par exemple, doivent effectuer un contrôle d'autorisation avant d'extraire des données pour un champ.

Un résolveur de pipeline est composé d'un modèle de mappage Avant, d'un modèle de mappage Après et d'une liste de Fonctions. Chaque fonction possède un modèle de mappage de requêtes et de réponses qu'elle exécute par rapport à une source de données. Comme un résolveur de pipeline délègue l'exécution à une liste de fonctions, il n'est lié à aucune source de données. Les résolveurs d'unités et les fonctions sont des primitives qui exécutent des opérations sur des sources de données. Consultez la présentation du modèle de mappage Resolver pour plus d'informations.

Étape 1 : Création d'un résolveur de pipeline

Dans la AWS AppSync console, accédez à la page Schéma.

Enregistrez le schéma suivant :

schema {
    query: Query
    mutation: Mutation
}

type Mutation {
    signUp(input: Signup): User
}

type Query {
    getUser(id: ID!): User
}

input Signup {
    username: String!
    email: String!
}

type User {
    id: ID!
    username: String
    email: AWSEmail
}

Nous allons câbler un résolveur de pipeline sur le signUpterrain sur le type de mutation. Dans le champ Type de mutation sur le côté droit, choisissez Attacher à côté du champ de signUp mutation. Sur la page de création d'un résolveur, cliquez sur Actions, puis sur Mettre à jour le moteur d'exécution. ChoisissezPipeline Resolver, puis choisissezVTL, puis choisissez Mettre à jour. La page doit désormais afficher trois sections : une zone de texte avant le mappage du modèle, une section Fonctions et une zone de texte après le mappage du modèle.

Notre résolveur de pipeline inscrit un utilisateur en validant tout d'abord l'adresse e-mail saisie, puis en enregistrant l'utilisateur dans le système. Nous allons encapsuler la validation de l'e-mail dans une validateEmailfonction, et la sauvegarde de l'utilisateur dans une saveUserfonction. La validateEmailfonction s'exécute d'abord, et si l'e-mail est valide, elle s'saveUserexécute.

Le flux d'exécution sera comme suit :

Comme nous allons probablement réutiliser la validateEmailfonction dans d'autres résolveursAPI, nous voulons éviter d'y accéder $ctx.args car ceux-ci changeront d'un champ GraphQL à l'autre. Au lieu de cela, nous pouvons utiliser le $ctx.stash pour stocker l'attribut e-mail depuis l'argument de champ de saisie signUp(input: Signup).

BEFOREmodèle de mappage :

## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}

La console fournit un modèle de AFTERmappage direct par défaut que nous utiliserons :

$util.toJson($ctx.result)

Choisissez Créer ou Enregistrer pour mettre à jour le résolveur.

Étape 2 : Création d'une fonction

Sur la page du résolveur de pipeline, dans la section Fonctions, cliquez sur Ajouter une fonction, puis sur Créer une nouvelle fonction. Il est également possible de créer des fonctions sans passer par la page du résolveur ; pour cela, dans la AWS AppSync console, rendez-vous sur la page Fonctions. Choisissez le bouton Créer une fonction. Créons une fonction permettant de vérifier si un e-mail est valide et provient d'un domaine spécifique. Si l'e-mail n'est pas valide, la fonction renvoie une erreur. Dans le cas contraire, elle transmet les données saisies.

Sur la page des nouvelles fonctions, choisissez Actions, puis Mettre à jour le moteur d'exécution. ChoisissezVTL, puis Mettre à jour. Assurez-vous d'avoir créé une source de données de NONEce type. Choisissez cette source de données dans la liste des noms des sources de données. Pour le nom de la fonction, entrezvalidateEmail. Dans la zone du code de fonction, remplacez tout par cet extrait de code :

#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
    $util.error("$ctx.stash.email is not a valid email.")
#end
{
    "payload": { "email": $util.toJson(${ctx.stash.email}) }
}

Collez ceci dans le modèle de mappage des réponses :

$util.toJson($ctx.result)

Passez en revue vos modifications, puis choisissez Créer. Nous venons de créer notre validateEmailfonction. Répétez ces étapes pour créer la saveUserfonction avec les modèles de mappage de demandes et de réponses suivants (Pour des raisons de simplicité, nous utilisons une source de NONEdonnées et prétendons que l'utilisateur a été enregistré dans le système après l'exécution de la fonction. ) :

Modèle de mappage de demande :

## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
    "payload": $util.toJson($ctx.prev.result)
}

Modèle de mappage de réponse :

## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($ctx.result)

Nous venons de créer notre saveUserfonction.

Étape 3 : Ajouter une fonction à un résolveur de pipeline

Nos fonctions auraient dû être ajoutées automatiquement au résolveur de pipeline que nous venons de créer. Si ce n'était pas le cas, ou si vous avez créé les fonctions via la page Fonctions, vous pouvez cliquer sur Ajouter une fonction sur la page du résolveur pour les joindre. Ajoutez à la fois validateEmailles saveUserfonctions et au résolveur. La validateEmailfonction doit être placée avant la saveUserfonction. Au fur et à mesure que vous ajoutez des fonctions, vous pouvez utiliser les options de déplacement vers le haut et de déplacement vers le bas pour réorganiser l'ordre d'exécution de vos fonctions. Passez en revue vos modifications, puis choisissez Enregistrer.

Étape 4 : Exécution d'une requête

Dans la AWS AppSync console, accédez à la page Requêtes. Dans l'explorateur, assurez-vous d'utiliser votre mutation. Si ce n'est pas le cas, choisissez Mutation dans la liste déroulante, puis choisissez+. Entrez la requête suivante :

mutation {
  signUp(input: {
    email: "nadia@myvaliddomain.com"
    username: "nadia"
  }) {
    id
    email
  }
}

Cela devrait renvoyer quelque chose comme :

{
  "data": {
    "signUp": {
      "id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
      "email": "nadia@myvaliddomain.com"
    }
  }
}

Nous avons inscrit notre utilisateur et validé l'e-mail saisi à l'aide d'un résolveur de pipeline. Pour suivre un didacticiel plus complet sur les résolveurs de pipeline, vous pouvez consulter le Didacticiel : Résolveurs de Pipeline