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á.
# Criação de consultas básicas (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](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers-js.html).
Os resolvedores do GraphQL conectam os campos em um esquema de tipo a uma fonte de dados. Os resolvedores são o mecanismo pelo qual as solicitações são atendidas. AWS AppSync pode criar e conectar automaticamente resolvedores a partir de um esquema ou criar um esquema e conectar resolvedores de uma tabela existente sem precisar escrever nenhum código.
Resolvedores em AWS AppSync uso JavaScript para converter uma expressão GraphQL em um formato que a fonte de dados possa usar. Como alternativa, os modelos de mapeamento podem ser escritos em [Apache VTL (Velocity Template Language)](https://velocity.apache.org/engine/2.0/vtl-reference.html) para converter uma expressão de GraphQL em um formato que a fonte de dados possa usar.
Esta seção mostrará como configurar resolvedores de VTL. [Um guia introdutório de programação em estilo tutorial para escrever resolvedores pode ser encontrado no guia de programação do [modelo de mapeamento do Resolver e os utilitários auxiliares disponíveis para uso durante a programação](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide) podem ser encontrados na referência de contexto do modelo de mapeamento do Resolver.](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference) AWS AppSync também tem fluxos de teste e depuração integrados que você pode usar ao editar ou criar do zero. Para obter mais informações, consulte [Resolvedores de teste e depuração](test-debug-resolvers.md#aws-appsync-test-debug-resolvers).
Recomendamos seguir este guia antes de tentar usar qualquer um dos tutoriais mencionados acima.
Nesta seção, vamos criar um resolvedor, adicionar um resolvedor para mutações e usar as configurações avançadas.
## Criar seu primeiro resolvedor
Seguindo os exemplos das seções anteriores, a primeira etapa é criar um resolvedor para seu tipo de `Query`.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSync console](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. No lado direito da página, há uma janela chamada **Resolvedores**. Essa caixa contém uma lista dos tipos e campos conforme definido na janela **Esquema** no lado esquerdo da página. Você pode anexar resolvedores aos campos. Por exemplo, no tipo de **consulta**, escolha **Anexar** ao lado do campo `getTodos`.
1. Na página **Criar resolvedor**, escolha a fonte de dados que você criou no guia [Anexar uma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html). Na janela **Configurar modelos de mapeamento**, você pode escolher os modelos genéricos de mapeamento de solicitação e resposta na lista suspensa à direita ou escrever suas próprias opções.
**nota**
A combinação de um modelo de mapeamento de solicitação com um modelo de mapeamento de resposta é chamado de resolvedor de unidades. Os resolvedores de unidades normalmente são destinados a realizar operações rotineiras, e recomendamos usá-los somente para operações individuais com um pequeno número de fontes de dados. Para operações mais complexas, recomendamos o uso de resolvedores de pipeline, que podem executar diversas operações com várias fontes de dados sequencialmente.
Para obter mais informações sobre a diferença entre os modelos de mapeamento de solicitação e resposta, consulte [Resolvedores de unidades](https://docs.aws.amazon.com//appsync/latest/devguide/resolver-mapping-template-reference-overview.html#unit-resolvers).
Para obter mais informações sobre o uso de resolvedores de pipeline, consulte [Resolvedores de pipeline](pipeline-resolvers.md#aws-appsync-pipeline-resolvers).
1. Para casos de uso comuns, o AWS AppSync console tem modelos integrados que você pode usar para obter itens de fontes de dados (por exemplo, todas as consultas de itens, pesquisas individuais etc.). Por exemplo, na versão simples do esquema de [Projetar seu esquema](designing-your-schema.md#aws-appsync-designing-your-schema), onde `getTodos` não tinha paginação, o modelo de mapeamento para listar os itens é o seguinte:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. Sempre é necessário ter um modelo de mapeamento da resposta para acompanhar a solicitação. O console fornece um padrão com o seguinte valor de passagem para listas:
```
$util.toJson($ctx.result.items)
```
Neste exemplo, o objeto `context` (com o alias de `$ctx`) para listas de itens tem o formato `$context.result.items`. Se a operação do GraphQL retorna um único item, ele seria `$context.result`. O AWS AppSync oferece funções auxiliares para operações comuns, como a função `$util.toJson` listada anteriormente, para formatar respostas corretamente. Para obter uma lista completa das funções, consulte [Referência do utilitário do modelo de mapeamento do resolvedor](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).
1. Escolha **Salvar resolvedor**.
------
#### [ API ]
1. Crie um objeto resolvedor chamando a API [https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_CreateResolver.html).
1. Você pode modificar os campos do seu resolvedor chamando a API [https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html](https://docs.aws.amazon.com/appsync/latest/APIReference/API_UpdateResolver.html).
------
#### [ CLI ]
1. Crie um resolvedor executando o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html).
Você precisará digitar 6 parâmetros para este comando específico:
1. O `api-id` da sua API.
1. O `type-name` do tipo que você deseja modificar em seu esquema. No exemplo do console, tínhamos `Query`.
1. O `field-name` do tipo que você deseja modificar em seu tipo. No exemplo do console, tínhamos `getTodos`.
1. A fonte de dados `data-source-name` que você criou no guia [Anexar uma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. O `request-mapping-template`, que é o corpo da solicitação. No exemplo do console, tínhamos:
```
{
"version" : "2017-02-28",
"operation" : "Scan"
}
```
1. O `response-mapping-template`, que é o corpo da resposta. No exemplo do console, tínhamos:
```
$util.toJson($ctx.result.items)
```
Veja um exemplo de comando:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Query --field-name getTodos --data-source-name TodoTable --request-mapping-template "{ "version" : "2017-02-28", "operation" : "Scan", }" --response-mapping-template ""$"util.toJson("$"ctx.result.items)"
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"resolver": {
"kind": "UNIT",
"dataSourceName": "TodoTable",
"requestMappingTemplate": "{ version : 2017-02-28, operation : Scan, }",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Query/resolvers/getTodos",
"typeName": "Query",
"fieldName": "getTodos",
"responseMappingTemplate": "$util.toJson($ctx.result.items)"
}
}
```
1. Para modificar os modelos de and/or mapeamento de campos de um resolvedor, execute o [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-resolver.html)comando.
Com exceção do parâmetro de `api-id`, os parâmetros usados no comando `create-resolver` serão substituídos pelos novos valores do comando `update-resolver`.
------
## Adicionar um resolvedor para mutações
A próxima etapa é criar um resolvedor para seu tipo de `Mutation`.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSync console](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. No tipo **Mutação**, escolha **Anexar** ao lado do seu campo `addTodo`.
1. Na página **Criar resolvedor**, escolha a fonte de dados que você criou no guia [Anexar uma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Na janela **Configurar modelos de mapeamento**, você precisará modificar o modelo de solicitação porque essa é uma mutação em que você está adicionando um novo item ao DynamoDB. Use o seguinte modelo de mapeamento da solicitação:
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
1. AWS AppSync converte automaticamente os argumentos definidos no `addTodo` campo do seu esquema do GraphQL em operações do DynamoDB. O exemplo anterior armazena registros no DynamoDB usando uma chave do `id` que é transmitida a partir do argumento da mutação como `$ctx.args.id`. Todos os outros campos transmitidos são mapeados automaticamente para atributos do DynamoDB com `$util.dynamodb.toMapValuesJson($ctx.args)`.
Para esse resolvedor, use o seguinte modelo de mapeamento da resposta:
```
$util.toJson($ctx.result)
```
AWS AppSync também suporta fluxos de trabalho de teste e depuração para edição de resolvedores. Use um objeto `context` de simulação para ver o valor transformado do modelo antes de invocar. Opcionalmente, você pode visualizar a execução de solicitação completa para uma fonte de dados de forma interativa ao executar uma consulta. Para obter mais informações, consulte [Resolvedores de teste e depuração](test-debug-resolvers.md#aws-appsync-test-debug-resolvers) e o [Monitoramento e registro em log](monitoring.md#aws-appsync-monitoring).
1. Escolha **Salvar resolvedor**.
------
#### [ API ]
Você também pode fazer isso APIs utilizando os comandos na seção [Criar seu primeiro resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e os detalhes dos parâmetros desta seção.
------
#### [ CLI ]
Além disso, é possível fazer isso no CLI utilizando os comandos na seção [Criar seu primeiro resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e os detalhes dos parâmetros desta seção.
------
Neste momento, se não estiver usando os resolvedores avançados você pode começar a usar a API GraphQL conforme descrito em [Uso da API](using-your-api.md#aws-appsync-using-your-api).
## Resolvedores avançados
Se estiver seguindo a seção Avançado e estiver criando um esquema de exemplo em [Projetar seu esquema](designing-your-schema.md#aws-appsync-designing-your-schema) para fazer uma verificação paginada, use o seguinte modelo de solicitação para o campo `getTodos`:
```
{
"version" : "2017-02-28",
"operation" : "Scan",
"limit": $util.defaultIfNull(${ctx.args.limit}, 20),
"nextToken": $util.toJson($util.defaultIfNullOrBlank($ctx.args.nextToken, null))
}
```
Para esse caso de uso de paginação, o mapeamento da resposta é mais do que apenas uma passagem porque ele deve conter o *cursor* (para que o cliente saiba em qual página começar) e o conjunto de resultados. O modelo de mapeamento é conforme mostrado a seguir:
```
{
"todos": $util.toJson($context.result.items),
"nextToken": $util.toJson($context.result.nextToken)
}
```
Os campos no modelo de mapeamento da resposta anterior devem corresponder aos campos definidos no tipo `TodoConnection`.
Se houver relações em que há uma tabela de `Comments`, e você estiver resolvendo o campo dos comentários no tipo `Todo` (que retorna um tipo de `[Comment]`), use um modelo de mapeamento que executa uma consulta mediante a segunda tabela. Para fazer isso, é necessário já ter criado uma fonte de dados para a tabela `Comments`, conforme descrito em Associar uma fonte de dados.
**nota**
Estamos usando uma operação de consulta mediante uma segunda tabela somente para fins ilustrativos. Você pode usar outra operação mediante o DynamoDB no lugar. Além disso, você pode extrair os dados de outra fonte de dados, como AWS Lambda o Amazon OpenSearch Service, porque a relação é controlada pelo esquema do GraphQL.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSync console](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. No tipo **Tarefas**, escolha **Anexar** ao lado do seu campo `comments`.
1. Na página **Criar resolvedor**, escolha sua fonte de dados da tabela de **comentários**. O nome padrão da tabela **Comentários** nos guias de início rápido é `AppSyncCommentTable`, mas pode variar dependendo do nome que você atribuiu a ela.
1. Adicione o seguinte trecho ao seu modelo de mapeamento da solicitação:
```
{
"version": "2017-02-28",
"operation": "Query",
"index": "todoid-index",
"query": {
"expression": "todoid = :todoid",
"expressionValues": {
":todoid": {
"S": $util.toJson($context.source.id)
}
}
}
}
```
1. O `context.source` faz referência ao objeto pai do campo atual que está sendo resolvido. Neste exemplo, `source.id` se refere ao objeto `Todo` individual que é, então, usado para a expressão de consulta.
Você pode usar o modelo de mapeamento da resposta de passagem da seguinte forma:
```
$util.toJson($ctx.result.items)
```
1. Escolha **Salvar resolvedor**.
1. Por fim, de volta à página **Esquema** no console, anexe um resolvedor ao campo `addComment` e especifique a fonte de dados da tabela `Comments`. Neste caso, o modelo de mapeamento da solicitação é um simples `PutItem` com o `todoid` específico que está comentado como um argumento, mas use o utilitário `$utils.autoId()` para criar uma chave de classificação única para o comentário da seguinte forma:
```
{
"version": "2017-02-28",
"operation": "PutItem",
"key": {
"todoid": { "S": $util.toJson($context.arguments.todoid) },
"commentid": { "S": "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Use um modelo da resposta de passagem da seguinte forma:
```
$util.toJson($ctx.result)
```
------
#### [ API ]
Você também pode fazer isso APIs utilizando os comandos na seção [Criar seu primeiro resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e os detalhes dos parâmetros desta seção.
------
#### [ CLI ]
Além disso, é possível fazer isso no CLI utilizando os comandos na seção [Criar seu primeiro resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html#create-your-first-resolver) e os detalhes dos parâmetros desta seção.
------