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

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.

Pour plus d'informations sur l'architecture d'un résolveur de JavaScript pipeline, consultez la présentation des JavaScriptrésolveurs.

É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. Réglez le résolveur sur pipeline resolver et le APPSYNC_JS runtime, puis créez le résolveur.

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 le suivant :

1. Mutation. signUp gestionnaire de demandes de résolution

2. validateEmail fonction

3. saveUser fonction

4. Mutation. signUp gestionnaire de réponses du résolveur

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).

Mettez à jour le code de votre résolveur en remplaçant vos fonctions de demande et de réponse :

export function request(ctx) {
    ctx.stash.email = ctx.args.input.email
    return {};
}

export function response(ctx) {
    return ctx.prev.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.

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. Entrez le nom de la fonctionvalidateEmail. Dans la zone du code de fonction, remplacez tout par cet extrait de code :

import { util } from '@aws-appsync/utils';

export function request(ctx) {
  const { email } = ctx.stash;
  const valid = util.matches(
    '^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
    email
  );
  if (!valid) {
    util.error(`"${email}" is not a valid email.`);
  }

  return { payload: { email } };
}

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

Passez en revue vos entrées, puis choisissez Créer. Nous venons de créer notre validateEmailfonction. Répétez ces étapes pour créer la saveUserfonction avec le code suivant (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. ) :

import { util } from '@aws-appsync/utils';

export function request(ctx) {
  return ctx.prev.result;
}

export function response(ctx) {
  ctx.result.id = util.autoId();
  return 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 signUp 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: "[e-mail]", username: "nadia"}) {
    id
    username
  }
}

Cela devrait renvoyer quelque chose comme :

{
  "data": {
    "signUp": {
      "id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
      "username": "nadia"
    }
  }
}

Nous avons inscrit notre utilisateur et validé l'e-mail saisi à l'aide d'un résolveur de pipeline.