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 de 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. Grâce aux résolveurs de pipelines, 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 sur 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 raccorder un résolveur de pipeline au champ signUp sur le type Mutation. Dans le type de mutation sur le côté droit, choisissez Joindre à 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 devrait maintenant 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 d'e-mail dans une fonction validateEmail et l'enregistrement de l'utilisateur dans une fonction saveUser. La fonction validateEmail s'exécute d'abord, puis si l'e-mail est valide, alors la fonction saveUser s'exécute.

Le flux d'exécution sera comme suit :

Comme nous allons probablement réutiliser la fonction ValidateEmail dans d'autres résolveurs de notre API, 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).

AVANT le modè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 mappage AFTER 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 nouvelle page de fonctions, choisissez Actions, puis Update runtime. ChoisissezVTL, puis Mettre à jour. Assurez-vous d'avoir créé une source de données du type AUCUN. Choisissez cette source de données dans la liste Nom de la source de données. Pour le nom de la fonction, entrezvalidateEmail. Dans la zone de code de fonction, remplacez tout par cet extrait :

#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 fonction validateEmail. Répétez ces étapes pour créer la fonction SaveUser avec les modèles de mappage de requêtes et de réponses suivants (Par souci de simplicité, nous utilisons une source de données NONE et supposons 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 fonction SaveUser.

É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'est 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 les fonctions ValidateEmail et SaveUser au résolveur. La fonction validateEmail doit être placée avant la fonction saveUser. 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. Vérifiez 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