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

# Uso de resolvedores locais no AWS AppSync
<a name="tutorial-local-resolvers"></a>

**nota**  
Agora, oferecemos suporte principalmente ao runtime do APPSYNC\$1JS e sua documentação. Considere usar o runtime do APPSYNC\$1JS e seus guias disponíveis [aqui](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html).

O AWS AppSync permite que você use fontes de dados compatíveis (AWS Lambda, Amazon DynamoDB ou Amazon OpenSearch Service) para executar diversas operações. No entanto, em determinados cenários, uma chamada para uma fonte de dados compatível pode não ser necessária.

É aí que o resolvedor local se torna útil. Em vez de chamar uma fonte de dados remota, o resolvedor local apenas **encaminhará** o resultado do modelo de mapeamento da solicitação para o modelo de mapeamento da resposta. A resolução do campo não deixará o AWS AppSync.

Os resolvedores locais são úteis em vários casos de uso. O caso de uso mais popular é a publicação de notificações sem acionar uma chamada da fonte de dados. Para demonstrar esse caso de uso, vamos criar um aplicativo de paginação, onde os usuários podem paginar uns aos outros. Esse exemplo utiliza *Assinaturas*, portanto se não estiver familiarizado com *Assinaturas*, siga o tutorial [Dados em tempo real](aws-appsync-real-time-data.md).

## Criar o aplicativo de paginação
<a name="create-the-paging-application"></a>

No aplicativo de paginação, os clientes podem assinar uma caixa de entrada e enviar páginas para outros clientes. Cada página inclui uma mensagem. Aqui está o esquema:

```
schema {
    query: Query
    mutation: Mutation
    subscription: Subscription
}

type Subscription {
    inbox(to: String!): Page
    @aws_subscribe(mutations: ["page"])
}

type Mutation {
    page(body: String!, to: String!): Page!
}

type Page {
    from: String
    to: String!
    body: String!
    sentAt: String!
}

type Query {
    me: String
}
```

Vamos anexar um resolvedor no campo `Mutation.page`. No painel **Esquema**, clique em *Anexar resolvedor* ao lado da definição do campo no painel à direita. Crie uma nova fonte de dados do tipo *Nenhum* e chame-a de *PageDataSource*.

Para o modelo de mapeamento da solicitação, insira:

```
{
  "version": "2017-02-28",
  "payload": {
    "body": $util.toJson($context.arguments.body),
    "from": $util.toJson($context.identity.username),
    "to":  $util.toJson($context.arguments.to),
    "sentAt": "$util.time.nowISO8601()"
  }
}
```

E para o modelo de mapeamento da resposta, selecione o padrão *Encaminhar o resultado*. Salve o resolvedor. O aplicativo agora está pronto, vamos paginar\$1

## Enviar e assinar páginas
<a name="send-and-subscribe-to-pages"></a>

Para que os clientes recebam páginas, primeiro eles devem assinar uma caixa de entrada.

No painel **Consultas** vamos executar a assinatura `inbox`:

```
subscription Inbox {
    inbox(to: "Nadia") {
        body
        to
        from
        sentAt
    }
}
```

 *Nadia* receberá páginas sempre que a mutação `Mutation.page` for invocada. Vamos invocar a mutação executando a mutação:

```
mutation Page {
    page(to: "Nadia", body: "Hello, World!") {
        body
        to
        from
        sentAt
    }
}
```

Nós acabamos de demonstrar o uso de resolvedores locais, enviando uma Página e recebendo-a sem sair do AWS AppSync.