As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Configurando e usando resolvedores de pipeline em AWS AppSync () JavaScript
<a name="pipeline-resolvers-js"></a>

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](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js).

## Etapa 1: criar um resolvedor de pipeline
<a name="create-a-pipeline-resolver-js"></a>

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 campo **signUp** no tipo **Mutação**. 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 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. Manipulador de solicitações do resolvedor Mutation.signUp

1. Função validateEmail

1. Função saveUser

1. Manipulador de respostas 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)`.

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: criar uma função
<a name="create-a-function-js"></a>

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.

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:

```
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 função **validateEmail**. Repita essas etapas para criar a função **saveUser** com o código a seguir (para 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.):

```
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 função **saveUser**.

## Etapa 3: adicionar uma função a um resolvedor de pipeline
<a name="adding-a-function-to-a-pipeline-resolver-js"></a>

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

## Etapa 4: executar uma consulta
<a name="running-a-query-js"></a>

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: "nadia@myvaliddomain.com", 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.