Resolvedores de pipeline (VTL)

nota

Agora, oferecemos suporte principalmente ao runtime do APPSYNC_JS e sua documentação. Considere usar o runtime do APPSYNC_JS e seus guias disponíveis aqui.

O AWS AppSync executa os resolvedores em um campo do 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.

Um resolvedor de pipeline é composto de um modelo de mapeamento Anterior, um modelo de mapeamento Posterior e uma lista de Funções. Cada função possui um modelo de mapeamento de solicitação e resposta que é executado mediante uma fonte de dados. Como um resolvedor de pipeline delega a execução a uma lista de funções, ele não está vinculado a nenhuma fonte de dados. Os resolvedores de unidade e funções que executam a operação mediante fontes de dados são primitivos. Consulte Visão geral do modelo de mapeamento do resolvedor para obter mais informações.

Criar um resolvedor de pipeline

No console do AWS AppSync, vá até 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 campo signUp no tipo Mutação. No tipo Mutação no lado direito, escolha Anexar ao lado do campo de mutação signUp. Na página de criação do resolvedor, clique em Ações e depois em Atualizar runtime. Escolha Pipeline Resolver e VTL e selecione Atualizar. Agora, a página deve mostrar 3 seções, uma área de texto Modelo de mapeamento anterior, uma seção Funções e uma área de texto Modelo de mapeamento posterior.

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 de e-mail dentro de uma função validateEmail e salvar o usuário dentro de uma função saveUser. A função validateEmail é executada primeiro e, se o e-mail for válido, a função saveUser será executada.

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

1. Modelo de mapeamento de solicitação do resolvedor Mutation.signUp

2. Função validateEmail

3. Função saveUser

4. Modelo de mapeamento de resposta do resolvedor Mutation.signUp

Provavelmente reutilizaremos a função validateEmail em outros resolvedores em nossa API. Sendo assim, queremos evitar o acesso a $ctx.args, já que 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).

Modelo de mapeamento ANTERIOR:

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

O console fornece um modelo de mapeamento POSTERIOR de passagem padrão que usaremos:

$util.toJson($ctx.result)

Escolha Criar ou Salvar para atualizar o resolvedor.

Criar 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 isso, no console do AWS AppSync, vá para 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.

Na página da nova função, escolha Ações e, em seguida, Atualizar runtime. Escolha VTL, depois, Atualizar. Crie uma fonte de dados do tipo NONE. 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:

#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}) }
}

Cole isso no modelo de mapeamento de resposta:

$util.toJson($ctx.result)

Verifique suas escolhas e selecione Criar. Acabamos de criar nossa função validateEmail. Repita essas etapas para criar a função saveUser com o código a seguir (a fim de simplificar, usamos a fonte de dados NONE e fingimos que o usuário foi salvo no sistema após a execução da função):

Modelo de mapeamento de solicitação:

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

Modelo de mapeamento da resposta:

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

Acabamos de criar nossa função saveUser.

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 de resolvedor para anexá-las. Adicione as funções validateEmail e saveUser ao resolvedor. A função validateEmail deve ser colocada antes da função saveUser. À 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.

Executar uma consulta

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

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

Ela deve retornar algo semelhante a:

{
  "data": {
    "signUp": {
      "id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
      "email": "[e-mail]"
    }
  }
}

Cadastramos com sucesso nosso usuário e validamos o e-mail de entrada usando um resolvedor de pipeline. Para seguir um tutorial mais completo com foco em resolvedores de pipeline, você pode acessar Tutorial: Resolvedores de pipeline