Configurando e usando resolvedores de pipeline em AWS AppSync () JavaScript

AWS AppSync executa resolvedores em um campo GraphQL. Em alguns casos, os aplicativos requerem a execução de várias operações para resolver um único campo do GraphQL. Com os resolvedores de pipeline, os desenvolvedores agora podem elaborar operações chamadas Funções e executá-las em sequência. Os resolvedores de pipeline são úteis para aplicativos que, por exemplo, exigem a execução de uma verificação de autorização antes de obter dados para um campo.

Para obter mais informações sobre a arquitetura de um resolvedor de JavaScript pipeline, consulte a visão geral dos JavaScript resolvedores.

Etapa 1: criar um resolvedor de pipeline

No AWS AppSync console, acesse a página Esquema.

Salve o seguinte esquema:

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
}

Vamos conectar um resolvedor de pipeline ao signUpcampo no tipo Mutation. No tipo Mutação no lado direito, escolha Anexar ao lado do campo de mutação signUp. Defina o resolvedor como pipeline resolver e o runtime APPSYNC_JS e, em seguida, crie o resolvedor.

Nosso resolvedor de pipeline cadastra um usuário validando primeiro a entrada do endereço de e-mail e salvando o usuário no sistema. Vamos encapsular a validação do e-mail dentro de uma validateEmailfunção e o salvamento do usuário dentro de uma saveUserfunção. A validateEmailfunção é executada primeiro e, se o e-mail for válido, a saveUserfunção será executada.

O fluxo de execução será da seguinte forma:

1. Mutação. signUp manipulador de solicitações do resolvedor

2. validateEmail função

3. saveUser função

4. Mutação. signUp manipulador de resposta do resolvedor

Como provavelmente reutilizaremos a validateEmailfunção em outros resolvedores do nossoAPI, queremos evitar o acesso ctx.args porque eles mudarão de um campo do GraphQL para outro. Em vez disso, podemos usar o ctx.stash para armazenar o atributo de e-mail a partir do argumento de campo de entrada signUp(input: Signup).

Atualize seu código de resolvedor substituindo as funções de solicitação e resposta:

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

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

Escolha Criar ou Salvar para atualizar o resolvedor.

Etapa 2: Criando uma função

Na página do resolvedor de pipeline, na seção Funções, clique em Adicionar função e em Criar função. Também é possível criar funções sem passar pela página do resolvedor; para fazer isso, no AWS AppSync console, acesse a página Funções. Selecione o botão Criar função. Vamos criar uma função que verifique se um e-mail é válido e proveniente de um domínio específico. Se o e-mail não for válido, a função gerará um erro. Caso contrário, ele encaminha qualquer entrada fornecida.

Certifique-se de ter criado uma fonte de dados NONEdesse tipo. Escolha a fonte de dados na lista Nome da fonte de dados. Em nome da função, insira validateEmail. Na área código da função, substitua tudo por este trecho:

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;
}

Revise suas entradas e selecione Criar. Acabamos de criar nossa validateEmailfunção. Repita essas etapas para criar a saveUserfunção com o código a seguir (para simplificar, usamos uma fonte de NONEdados e fingimos que o usuário foi salvo no sistema após a execução da função. ):

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;
}

Acabamos de criar nossa saveUserfunção.

Etapa 3: Adicionar uma função a um resolvedor de pipeline

Nossas funções devem ter sido adicionadas automaticamente ao resolvedor de pipeline que acabamos de criar. Se não foi esse o caso ou se você criou as funções por meio da página Funções, é possível clicar em Adicionar função na página do signUp resolvedor para anexá-las. Adicione as saveUserfunções validateEmaile ao resolvedor. A validateEmailfunção deve ser colocada antes da saveUserfunção. À medida que você adiciona mais funções, pode usar as setas para cima e para baixo para reorganizar a ordem de execução das funções. Revise suas alterações e escolha Salvar.

Etapa 4: Executar uma consulta

No AWS AppSync console, acesse a página Consultas. No explorador, verifique se você está usando a mutação. Se não estiver, escolha Mutation na lista suspensa e escolha +. Digite a consulta a seguir:

mutation {
  signUp(input: {email: "[e-mail]", username: "nadia"}) {
    id
    username
  }
}

Ela deve retornar algo semelhante a:

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

Cadastramos com sucesso nosso usuário e validamos o e-mail de entrada usando um resolvedor de pipeline.