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á.
# Configuração de resolvedores no AWS AppSync
Nas seções anteriores, você aprendeu a criar o esquema e a fonte de dados do GraphQL e, em seguida, vinculá-los no serviço AWS AppSync. No esquema, você pode ter estabelecido um ou mais campos (operações) na consulta e na mutação. Embora o esquema descrevesse os tipos de dado que as operações solicitariam da fonte de dados, ele nunca implementou o modo como essas operações se comportariam em relação aos dados.
O comportamento de uma operação é sempre implementado no resolvedor, que será vinculado ao campo que executa a operação. Para obter mais informações sobre como os resolvedores funcionam em geral, consulte a página [Resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html).
Em AWS AppSync, o resolvedor é vinculado a um runtime, que é o ambiente no qual o resolvedor é executado. Os runtimes determinam a linguagem na qual o resolvedor será gravado. Atualmente, há dois runtimes compatíveis: APPSYNC\$1JS (JavaScript) e Apache Velocity Template Language (VTL).
Ao implementar resolvedores, eles seguem uma estrutura geral:
+ **Etapa Anterior**: quando uma solicitação é feita pelo cliente, os resolvedores dos campos do esquema que estão sendo usados (normalmente consultas, mutações e assinaturas) recebem os dados da solicitação. O resolvedor começará a processar os dados da solicitação com um manipulador de etapas anteriores, o que permite que algumas operações de pré-processamento sejam executadas antes que os dados passem pelo resolvedor.
+ **Função(ões)**: Após a execução da etapa anterior, a solicitação é passada para a lista de funções. A primeira função na lista será executada na fonte de dados. Uma função é um subconjunto do código do resolvedor contendo seu próprio manipulador de solicitações e respostas. Um manipulador de solicitações pegará os dados da solicitação e executará operações na fonte de dados. O manipulador de respostas processará a resposta da fonte de dados antes de passá-la de volta para a lista. Se houver mais de uma função, os dados da solicitação serão enviados para a próxima função a ser executada na lista. As funções na lista serão executadas na ordem definida pelo desenvolvedor. Depois que todas as funções forem executadas, o resultado final será passado para a etapa posterior.
+ **Etapa Posterior**: A etapa Posterior é uma função do manipulador que permite realizar algumas operações finais na resposta da função final antes de passá-la para a resposta do GraphQL.
Esse fluxo é um exemplo de um resolvedor de pipeline. Os resolvedores de pipeline são compatíveis em ambos os runtimes. No entanto, essa é uma explicação simplificada do que os resolvedores de pipeline podem fazer. Além disso, estamos descrevendo apenas uma configuração possível do resolvedor. Para obter mais informações sobre as configurações de resolvedor compatíveis, consulte a [Visão geral dos resolvedores do JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) para APPSYNC\$1JS ou a [Visão geral do modelo de mapeamento do resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html) para VTL.
Como você pode ver, os resolvedores são modulares. Para que os componentes do resolvedor funcionem corretamente, eles devem ser capazes de examinar o estado da execução por meio de outros componentes. Na seção [Resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html), você sabe que cada componente no resolvedor pode receber informações essenciais sobre o estado da execução como um conjunto de argumentos (`args`, `context` etc.). Em AWS AppSync, isso é tratado estritamente pelo `context`. Trata-se de um contêiner para as informações sobre o campo que está sendo resolvido. Isso pode incluir tudo, desde argumentos passados, resultados, dados de autorização, dados de cabeçalho etc. Para obter mais informações sobre o contexto, consulte [Referência do objeto de contexto do resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) para APPSYNC\$1JS ou a [Referência de contexto do modelo de mapeamento do resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html) para VTL.
O contexto não é a única ferramenta que você pode usar para implementar seu resolvedor. O AWS AppSync suporta uma ampla variedade de utilitários para geração de valor, tratamento de erros, análise, conversão etc. Você pode ver uma lista de utilitários [aqui](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) para APPSYNC\$1JS ou [aqui](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference.html) para VTL.
Nas seções a seguir, você vai aprender a configurar resolvedores na API do GraphQL.
**Topics**
+ [Criação de consultas básicas () JavaScript](configuring-resolvers-js.md)
+ [Criação de consultas básicas (VTL)](configuring-resolvers.md)
# Criação de consultas básicas () JavaScript
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.
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 descreve como configurar resolvedores usando o. JavaScript A seção [Tutoriais do Resolver (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) fornece tutoriais detalhados sobre como implementar resolvedores usando. JavaScript A seção [Referência do Resolvedor (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html) fornece uma explicação das operações do utilitário que podem ser usadas com JavaScript resolvedores.
Recomendamos seguir este guia antes de tentar usar qualquer um dos tutoriais mencionados acima.
Nesta seção, mostraremos como criar e configurar resolvedores de consultas e mutações.
**nota**
Este guia pressupõe que você tenha criado seu esquema e tenha pelo menos uma consulta ou mutação. Se você estiver procurando por assinaturas (dados em tempo real), consulte [este guia](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html).
Nesta seção, abordaremos algumas etapas gerais para configurar resolvedores e mostraremos um exemplo com o esquema abaixo:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Criação de resolvedores de consultas básicos
Esta seção mostrará como criar um resolvedor de consultas básico.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. Insira os detalhes do esquema e da fonte de dados. Consulte as seções [Criar seu esquema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) e [Anexar uma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html) para obter mais informações.
1. Ao lado do editor de **esquemas**, há uma janela chamada **Resolvedores**. Essa caixa contém uma lista dos tipos e campos conforme definido na janela **Esquema**. É possível anexar resolvedores aos campos. Você provavelmente estará anexando resolvedores às suas operações de campo. Nesta seção, veremos configurações de consultas simples. Em **Tipo de consulta**, escolha **Anexar** ao lado do campo da sua consulta.
1. Na página **Anexar resolvedor**, em **Tipo de resolvedor**, você pode escolher entre resolvedores de pipeline ou de unidade. Para obter mais informações sobre esses tipos de regra, consulte [Resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Este guia fará uso de `pipeline resolvers`.
**dica**
Ao criar resolvedores de pipeline, suas fontes de dados serão anexadas às funções do pipeline. As funções são geradas depois que você cria o próprio resolvedor de pipeline, e é por isso que não há opção de configurá-lo nesta página. Se você estiver usando um resolvedor de unidades, a fonte de dados estará vinculada diretamente ao resolvedor, portanto, você o definiria nesta página.
Para o **tempo de execução do Resolver**, escolha `APPSYNC_JS` ativar o JavaScript tempo de execução.
1. Você pode ativar o [armazenamento em cache](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) dessa API. Recomendamos desativar esse atributo por enquanto. Selecione **Criar**.
1. Na página **Editar resolvedor**, há um editor de código chamado **Código do resolvedor** que permite implementar a lógica para o manipulador e a resposta do resolvedor (etapas anterior e posterior). Para obter mais informações, consulte a [visão geral dos JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
**nota**
Em nosso exemplo, vamos deixar a solicitação em branco e a resposta definida para retornar o resultado da última fonte de dados do [contexto](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html):
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Abaixo dessa seção, há uma tabela chamada **Funções**. As funções permitem que você implemente códigos que possam ser reutilizados em vários resolvedores. Em vez de reescrever ou copiar sempre o código, você pode armazenar o código-fonte como uma função a ser adicionada a um resolvedor sempre que precisar.
As funções compõem a maior parte da lista de operações de um pipeline. Ao usar várias funções em um resolvedor, você define a ordem das funções, e elas serão executadas nessa ordem sequencialmente. Elas são executadas depois da função de solicitação e antes do início da função de resposta.
Para adicionar uma nova função, em **Funções**, escolha **Adicionar função** e, em seguida, **Criar nova função**. Como alternativa, pode haver um botão **Criar função** para escolher.
1. Escolha uma fonte de dados. Essa será a fonte de dados em que o resolvedor vai atuar.
**nota**
Em nosso exemplo, estamos anexando um resolvedor para `getPost`, que recupera um objeto `Post` pelo `id`. Vamos supor que já tenhamos configurado uma tabela do DynamoDB para esse esquema. Sua chave de partição está vazia e definida como `id`.
1. Insira um `Function name`.
1. Em **Código da função**, você precisará implementar o comportamento da função. Isso pode ser confuso, mas cada função terá seu próprio manipulador local de solicitações e respostas. A solicitação é executada e, em seguida, a invocação da fonte de dados é feita para lidar com a solicitação e, em seguida, a resposta da fonte de dados é processada pelo manipulador. O resultado é armazenado no objeto do [contexto](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html). Depois disso, a próxima função na lista será executada ou transmitida para o manipulador de resposta da etapa posterior, se for a última.
**nota**
Em nosso exemplo, estamos anexando um resolvedor ao `getPost`, que obtém uma lista de objetos `Post` da fonte de dados. Nossa função de solicitação solicitará os dados da nossa tabela, a tabela passará sua resposta para o contexto (ctx) e, em seguida, a resposta retornará o resultado no contexto. AWS AppSync A força da está em sua interconexão com outros serviços. AWS Como estamos usando o DynamoDB, temos [um conjunto de operações](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) para simplificar processos como esses. Também temos alguns exemplos padronizados para outros tipos de fontes de dados.
Nosso código será semelhante a este:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Nesta etapa, adicionamos duas funções:
`request`: o manipulador de solicitações executa a operação de recuperação na fonte de dados. O argumento contém o objeto de contexto (`ctx`) ou alguns dados que estão disponíveis para todos os resolvedores que executam uma operação específica. Por exemplo, ele pode conter dados de autorização, os nomes dos campos que estão sendo resolvidos etc. A instrução return executa uma operação de [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) (confira exemplos [aqui](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html)). Como estamos trabalhando com o DynamoDB, podemos usar algumas das operações desse serviço. A verificação executa uma busca básica de todos os itens em nossa tabela. O resultado dessa operação é armazenado no objeto de contexto como um contêiner de `result` antes de ser transmitido ao manipulador de respostas. A `request` é executada antes da resposta no pipeline.
`response`: o manipulador de respostas que retorna o resultado da `request`. O argumento é o objeto de contexto atualizado e a instrução de retorno é `ctx.prev.result`. Neste ponto do guia, é possível que você não conheça esse valor. `ctx` refere-se ao objeto de contexto, e `prev` refere-se à operação anterior no pipeline, que era nossa `request`. O `result` contém os resultados do resolvedor à medida que ele se move pelo pipeline. Se você juntar tudo isso, `ctx.prev.result` está retornando o resultado da última operação realizada, que foi o manipulador da solicitação.
1. Depois de concluir, escolha **Criar**.
1. De volta à tela do resolvedor, em **Funções**, escolha o menu suspenso **Adicionar função** e inclua sua função na sua lista.
1. Escolha **Salvar** para atualizar o resolvedor.
------
#### [ CLI ]
**Para adicionar sua função**
+ Crie uma função para seu resolvedor de pipeline usando o comando `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`.
Você precisará inserir alguns parâmetros para esse comando específico:
1. O `api-id` da sua API.
1. O `name` da função no AWS AppSync console.
1. O `data-source-name`, ou o nome da fonte de dados que a função usará. Ele já deve ter sido criado e vinculado à sua API do GraphQL no serviço do AWS AppSync .
1. O`runtime`, ou ambiente e idioma da função. Para JavaScript, o nome deve ser`APPSYNC_JS`, e o tempo de execução,`1.0.0`.
1. O `code`, ou manipuladores de solicitações e respostas de sua função. Embora você possa digitá-lo manualmente, é muito mais fácil adicioná-lo a um arquivo .txt (ou formato similar) e depois transmiti-lo como argumento.
**nota**
Nosso código de consulta estará em um arquivo transmitido como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Veja um exemplo de comando:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**nota**
Certifique-se de gravar o `functionId` em algum lugar, pois isso será usado para anexar a função ao solucionados.
**Criar seu resolvedor**
+ Crie uma função de pipeline para `Query` executando o comando `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`.
Você precisará inserir alguns parâmetros para esse comando específico:
1. O `api-id` da sua API.
1. O `type-name`, ou o tipo de objeto especial em seu esquema (consulta, mutação, assinatura).
1. O `field-name` ou a operação do campo no tipo de objeto especial a ser anexado ao resolvedor.
1. O `kind`, que especifica um resolvedor de unidade ou pipeline. Defina como `PIPELINE` para ativar as funções do pipeline.
1. A `pipeline-config`, ou as funções a serem anexadas ao resolvedor. É preciso saber os valores de `functionId` de suas funções. A ordem da listagem é importante.
1. O`runtime`, que foi `APPSYNC_JS` (JavaScript). Atualmente o `runtimeVersion` é`1.0.0`.
1. O `code`, que contém os manipuladores das etapas anterior e posterior.
**nota**
Nosso código de consulta estará em um arquivo transmitido como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Veja um exemplo de comando:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**dica**
[Antes de usar o CDK, recomendamos revisar a [documentação oficial](https://docs.aws.amazon.com/cdk/v2/guide/home.html) do CDK junto com AWS AppSync a referência do CDK.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
As etapas listadas abaixo mostram apenas um exemplo geral do trecho usado para adicionar um recurso específico. Isso **não** é uma solução funcional para seu código de produção. Também presumimos que você já tenha uma aplicação em funcionamento.
Uma aplicação básica precisará do seguinte:
1. Diretivas de importação de serviços
1. Código do esquema
1. Gerador de fontes de dados
1. Código da função
1. Código do resolvedor
Nas seções [Projetar seu esquema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) e [Anexar uma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), sabemos que o arquivo de pilha incluirá as diretivas de importação do formulário:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**nota**
Nas seções anteriores, declaramos apenas como importar AWS AppSync construções. Em código real, você precisará importar mais serviços apenas para executar a aplicação. Em nosso exemplo, se criássemos um aplicativo CDK muito simples, importaríamos pelo menos o AWS AppSync serviço junto com nossa fonte de dados, que era uma tabela do DynamoDB. Também precisaríamos importar algumas estruturas adicionais para implantar a aplicação:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Para resumir cada uma delas:
`import * as cdk from 'aws-cdk-lib';`: isso permite que você defina a aplicação e as estruturas do CDK, como a pilha. Ela também contém algumas funções utilitárias relevantes para nosso aplicativo, como a manipulação de metadados. Se você já conhece essa diretiva de importação, mas não sabe por que a biblioteca principal do CDK não está sendo usada aqui, consulte a página de [migração](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html).
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: isso importa o [serviço do AWS AppSync](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: isso importa o [serviço do DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`: precisamos disso para definir a [estrutura](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html)-raiz.
O tipo de importação depende dos serviços que você está chamando. Recomendamos consultar a documentação do CDK para ver exemplos. O esquema na parte superior da página será um arquivo separado na sua aplicação do CDK como um arquivo `.graphql`. No arquivo de pilha, podemos associá-lo a um novo GraphQL usando este formato:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**nota**
No escopo do `add_api`, vamos adicionar uma nova API GraphQL usando a `new` palavra-chave seguida por `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)`. Nosso escopo é `this`, o ID do CFN é `graphQL-example`, e nossas propriedades são `my-first-api` (nome da API no console) e `schema.graphql` (o caminho absoluto para o arquivo do esquema).
Para incluir uma fonte de dados, primeiro você precisa adicionar sua fonte de dados à pilha. Em seguida, associá-la à API GraphQL usando o método específico da fonte. A associação acontecerá quando seu resolvedor funcionar. Enquanto isso, vamos usar um exemplo criando a tabela do DynamoDB usando `dynamodb.Table`:
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**nota**
Se usássemos isso em nosso exemplo, adicionaríamos uma nova tabela do DynamoDB com o ID do CFN e uma chave de partição `posts-table` do `id (S)`.
Em seguida, precisamos implementar nosso resolvedor no arquivo de pilha. Veja a seguir um exemplo de uma consulta simples que verifica todos os itens em uma tabela do DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**nota**
Primeiro, criamos uma função chamada `add_func`. Essa ordem de criação pode parecer um pouco contraintuitiva, mas você precisa criar as funções em seu resolvedor de pipeline antes de criar o próprio resolvedor. Uma função segue o formato:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Nosso escopo era `this`, nosso ID de CFN, `func-get-posts`, e nossas propriedades continham os detalhes reais da função. Dentro das propriedades, incluímos:
A `name` da função que estará presente no AWS AppSync console (`get_posts_func_1`).
A API GraphQL que criamos anteriormente (`add_api`).
A fonte de dados; esse é o ponto em que vinculamos a fonte de dados ao valor da API GraphQL e a anexamos à função. Pegamos a tabela que criamos (`add_ddb_table`) e a anexamos à API GraphQL (`add_api`) usando um dos métodos `GraphqlApi` ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)). O valor do ID (`table-for-posts`) é o nome da fonte de dados no console do AWS AppSync . Para obter a lista dos métodos específicos da fonte, consulte as seguintes páginas:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
O código contém os manipuladores de solicitações e respostas da nossa função, que são uma simples digitalização e retorno.
O runtime especifica que queremos usar a versão 1.0.0 do runtime do APPSYNC\$1JS. Observe que atualmente essa é a única versão disponível do APPSYNC\$1JS.
Em seguida, precisamos anexar a função ao resolvedor de pipeline. Criamos nosso resolvedor usando o formulário:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Nosso escopo era `this`, nosso ID de CFN, `pipeline-resolver-get-posts`, e nossas propriedades continham os detalhes reais da função. Dentro das propriedades, incluímos:
A API GraphQL que criamos anteriormente (`add_api`).
O nome do tipo de objeto especial; essa é uma operação de consulta, então só adicionamos o valor da `Query`.
O nome do campo (`getPost`) é aquele no esquema abaixo do tipo de `Query`.
O código contém seus manipuladores de antes e depois. Nosso exemplo só vão retornar os resultados que estavam no contexto depois que a função tiver executado a operação.
O runtime especifica que queremos usar a versão 1.0.0 do runtime do APPSYNC\$1JS. Observe que atualmente essa é a única versão disponível do APPSYNC\$1JS.
A configuração do pipeline contém a referência à função que criamos (`add_func`).
------
Para resumir o que aconteceu neste exemplo, você viu uma AWS AppSync função que implementou um manipulador de solicitações e respostas. A função foi responsável por interagir com sua fonte de dados. O manipulador da solicitação enviou uma `Scan` operação para AWS AppSync, instruindo-a sobre qual operação realizar na sua fonte de dados do DynamoDB. O manipulador de respostas retornou a lista de itens (`ctx.result.items`). A lista de itens foi então mapeada automaticamente para o tipo `Post` GraphQL.
## Criar resolvedores básicos de mutação
Esta seção mostrará como criar um resolvedor de mutação básico.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. Na seção **Resolvedores** e no tipo de **mutação**, escolha **Anexar** ao lado do seu campo.
**nota**
Em nosso exemplo, estamos anexando um resolvedor para `createPost`, que recupera um objeto `Post` para nossa tabela. Vamos supor que estamos usando a mesma tabela do DynamoDB da última seção. Sua chave de partição está vazia e definida como `id`.
1. Na página **Anexar resolvedor**, em **Tipo de resolvedor**, escolha `pipeline resolvers`. Como lembrete, você pode encontrar mais informações sobre resolvedores [aqui](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html). Para o **tempo de execução do Resolver**, escolha `APPSYNC_JS` ativar o JavaScript tempo de execução.
1. Você pode ativar o [armazenamento em cache](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html) dessa API. Recomendamos desativar esse atributo por enquanto. Selecione **Criar**.
1. Escolha **Adicionar função** e, em seguida, **Criar nova função**. Como alternativa, pode haver um botão **Criar função** para escolher.
1. Selecione sua fonte de dados. Essa deve ser a fonte cujos dados você manipulará com a mutação.
1. Insira um `Function name`.
1. Em **Código da função**, você precisará implementar o comportamento da função. Isso é uma mutação, portanto, o ideal é que a solicitação realize alguma operação de mudança de estado na fonte de dados invocada. O resultado será processado pela função de resposta.
**nota**
O `createPost` adiciona ou “insere” um novo `Post` na tabela com nossos parâmetros como dados. Isso pode ser semelhante a:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Nesta etapa, adicionamos as funções `request` e `response`:
`request`: o manipulador da solicitação aceita o contexto como argumento. A instrução return do manipulador de solicitações executa um comando [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem), que é uma operação integrada do DynamoDB (confira alguns exemplos [neste link](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) ou [aqui](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData)). O comando `PutItem` adiciona um objeto `Post` à nossa tabela do DynamoDB considerando o valor `key` da partição (gerado automaticamente por `util.autoid()`) e `attributes` a partir da entrada do argumento de contexto (esses são os valores que vamos transmitir em nossa solicitação). A `key` é o `id`, e os `attributes` são os argumentos de campo `date` e `title`. Ambos são pré-formatados por meio do auxiliar [https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js) para trabalhar com a tabela do DynamoDB.
`response`: a resposta aceita o contexto atualizado e retorna o resultado do manipulador da solicitação.
1. Depois de concluir, escolha **Criar**.
1. De volta à tela do resolvedor, em **Funções**, escolha o menu suspenso **Adicionar função** e inclua sua função na sua lista.
1. Escolha **Salvar** para atualizar o resolvedor.
------
#### [ CLI ]
**Para adicionar sua função**
+ Crie uma função para seu resolvedor de pipeline usando o comando `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`.
Você precisará inserir alguns parâmetros para esse comando específico:
1. O `api-id` da sua API.
1. O `name` da função no AWS AppSync console.
1. O `data-source-name`, ou o nome da fonte de dados que a função usará. Ele já deve ter sido criado e vinculado à sua API do GraphQL no serviço do AWS AppSync .
1. O`runtime`, ou ambiente e idioma da função. Para JavaScript, o nome deve ser`APPSYNC_JS`, e o tempo de execução,`1.0.0`.
1. O `code`, ou manipuladores de solicitações e respostas de sua função. Embora você possa digitá-lo manualmente, é muito mais fácil adicioná-lo a um arquivo .txt (ou formato similar) e depois transmiti-lo como argumento.
**nota**
Nosso código de consulta estará em um arquivo transmitido como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Veja um exemplo de comando:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**nota**
Certifique-se de gravar o `functionId` em algum lugar, pois isso será usado para anexar a função ao solucionados.
**Criar seu resolvedor**
+ Crie uma função de pipeline para `Mutation` executando o comando `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`.
Você precisará inserir alguns parâmetros para esse comando específico:
1. O `api-id` da sua API.
1. O `type-name`, ou o tipo de objeto especial em seu esquema (consulta, mutação, assinatura).
1. O `field-name` ou a operação do campo no tipo de objeto especial a ser anexado ao resolvedor.
1. O `kind`, que especifica um resolvedor de unidade ou pipeline. Defina como `PIPELINE` para ativar as funções do pipeline.
1. A `pipeline-config`, ou as funções a serem anexadas ao resolvedor. É preciso saber os valores de `functionId` de suas funções. A ordem da listagem é importante.
1. O`runtime`, que foi `APPSYNC_JS` (JavaScript). Atualmente o `runtimeVersion` é`1.0.0`.
1. O `code`, que contém os manipuladores das etapas anterior e posterior.
**nota**
Nosso código de consulta estará em um arquivo transmitido como argumento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Veja um exemplo de comando:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**dica**
[Antes de usar o CDK, recomendamos revisar a [documentação oficial](https://docs.aws.amazon.com/cdk/v2/guide/home.html) do CDK junto com AWS AppSync a referência do CDK.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
As etapas listadas abaixo mostram apenas um exemplo geral do trecho usado para adicionar um recurso específico. Isso **não** é uma solução funcional para seu código de produção. Também presumimos que você já tenha uma aplicação em funcionamento.
+ Para fazer uma mutação, supondo que esteja no mesmo projeto, você pode adicioná-la ao arquivo de pilha como na consulta. Aqui está uma função e um resolvedor modificados para uma mutação que adiciona uma nova `Post` à tabela:
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**nota**
Como essa mutação e a consulta são estruturadas de forma semelhante, explicaremos apenas as alterações que implementamos para fazer a mutação.
Na função, alteramos o ID da CFN `func-add-post` e o nome para `add_posts_func_1` para refletir o fato de que estamos adicionando `Posts` à tabela. Na fonte de dados, fizemos uma nova associação à nossa tabela (`add_ddb_table`) no AWS AppSync console `table-for-posts-2` porque o `addDynamoDbDataSource` método exige isso. Lembre-se de que essa nova associação ainda está usando a mesma tabela que criamos anteriormente, mas agora temos duas conexões com ela no AWS AppSync console: uma para a consulta as `table-for-posts` e outra para a mutação as`table-for-posts-2`. O código foi alterado para adicionar uma `Post` gerando o valor do `id` automaticamente e aceitando a entrada de um cliente para o resto dos campos.
No resolvedor, mudamos o valor do ID para `pipeline-resolver-create-posts` a fim de refletir o fato de que estamos adicionando `Posts` à tabela. Para refletir a mutação no esquema, o nome do tipo mudou para `Mutation`, e o nome para `createPost`. A configuração do pipeline foi definida para nossa nova função de mutação `add_func_2`.
------
Para resumir o que está acontecendo neste exemplo, converte AWS AppSync automaticamente os argumentos definidos no `createPost` campo do seu esquema do GraphQL em operações do DynamoDB. O exemplo armazena registros no DynamoDB usando uma chave do `id`, que é criada automaticamente usando nosso auxiliar `util.autoId()`. Todos os outros campos que você passar para os argumentos de contexto (`ctx.args.input`) de solicitações feitas no AWS AppSync console ou de outra forma serão armazenados como atributos da tabela. Tanto a chave quanto os atributos são mapeados automaticamente para um formato compatível do DynamoDB usando o auxiliar `util.dynamodb.toMapValues(values)`.
AWS AppSync também oferece suporte a fluxos de trabalho de teste e depuração para edição de resolvedores. Use um objeto `context` de simulação para ver o valor do modelo transformado antes da invocá-lo. Uma alternativa é visualizar a execução de solicitação completa de uma fonte de dados de forma interativa ao executar uma consulta. Para obter mais informações, consulte [Resolvers de teste e depuração (JavaScript)](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) e [Monitoramento e registro](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring).
## Resolvedores avançados
Se você estiver seguindo a seção opcional de paginação em [Projetar seu esquema](designing-your-schema.md#aws-appsync-designing-your-schema), ainda precisará adicionar seu resolvedor à sua solicitação para usar a paginação. Nosso exemplo usou uma paginação de consulta chamada `getPosts` para retornar somente uma parte das coisas solicitadas por vez. O código do nosso resolvedor nesse campo pode ter a seguinte aparência:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Na solicitação, transmitimos no contexto dela. Nosso `limit` é*20*, o que significa que retornamos até 20 `Posts` na primeira consulta. Nosso cursor do `nextToken` está fixo na primeira entrada da `Post` na fonte de dados. Eles são transmitidos para os argumentos. Em seguida, a solicitação executa uma varredura desde a primeira `Post` até o número limite de varredura. A fonte de dados armazena o resultado no contexto, que é transmitido para a resposta. A resposta retorna as `Posts` que foram recuperadas e, em seguida, define `nextToken` como a entrada `Post` logo após o limite. A próxima solicitação é enviada para fazer exatamente a mesma coisa, mas começando pelo deslocamento logo após a primeira consulta. Lembre-se de que esses tipos de solicitações são feitos sequencialmente e não de maneira simultânea.
# Testando e depurando resolvedores em () AWS AppSync JavaScript
AWS AppSync executa resolvedores em um campo GraphQL em relação a uma fonte de dados. Ao trabalhar com resolvedores de pipeline, as funções interagem com suas fontes de dados. Conforme descrito na [visão geral dos JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html), as funções se comunicam com as fontes de dados usando manipuladores de solicitação e resposta gravados JavaScript e executados no `APPSYNC_JS` tempo de execução. Isso permite fornecer lógica e condições personalizadas antes e depois da comunicação com a fonte de dados.
Para ajudar os desenvolvedores a escrever, testar e depurar esses resolvedores, o AWS AppSync console também fornece ferramentas para criar uma solicitação e uma resposta do GraphQL com dados simulados até o resolvedor de campo individual. Além disso, você pode realizar consultas, mutações e assinaturas no AWS AppSync console e ver um fluxo de log detalhado de toda a solicitação da Amazon. CloudWatch Isso inclui resultados da fonte de dados.
## Testes com dados simulados
Quando um resolvedor do GraphQL é invocado, ele contém um objeto `context` que contém informações relevantes sobre a solicitação. Isso inclui argumentos de um cliente, informações de identidade e dados do campo pai do GraphQL. Ele também armazena os resultados da fonte de dados, que podem ser usados no manipulador de respostas. Para obter mais informações sobre essa estrutura e os utilitários auxiliares disponíveis para usar durante a programação, consulte a [Referência do objeto de contexto do resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
Ao escrever ou editar uma função de resolução, você pode passar um objeto de *contexto simulado* ou de *teste* para o editor do console. Isso permite que você veja como os manipuladores de solicitação e de resposta são avaliados sem realmente serem executados em uma fonte de dados. Por exemplo, você pode enviar um argumento `firstname: Shaggy` de teste e ver como ele avalia ao usar `ctx.args.firstname` no código do modelo. Você também pode testar a avaliação de qualquer utilitário auxiliar, como `util.autoId()` ou `util.time.nowISO8601()`.
### Teste de resolvedores
Este exemplo usará o AWS AppSync console para testar os resolvedores.
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **Barra lateral**, escolha **Funções**.
1. Escolha uma função existente.
1. Na parte superior da página **Atualizar função**, escolha **Selecionar contexto de teste** e, em seguida, escolha **Criar novo contexto**.
1. Selecione um objeto de contexto de amostra ou preencha o JSON manualmente na janela **Configurar contexto de teste**.
1. Insira um **nome de contexto de texto**.
1. Clique no botão **Salvar**.
1. Para avaliar o resolvedor usando esse objeto de contexto simulado, escolha **Executar teste**.
Como exemplo mais prático, digamos que você tenha um aplicativo que armazena um tipo do GraphQL `Dog` que usa a geração automática de ID para objetos e os armazena no Amazon DynamoDB. Você também deseja gravar alguns valores dos argumentos de uma mutação do GraphQL e permitir que apenas usuários específicos vejam uma resposta. O trecho a seguir mostra a aparência do esquema:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Você pode escrever uma AWS AppSync função e adicioná-la ao seu `addDog` resolvedor para lidar com a mutação. Para testar sua AWS AppSync função, você pode preencher um objeto de contexto, como no exemplo a seguir. Ele tem argumentos do cliente de `name` e `age`, e um `username` preenchido no objeto `identity`:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Você pode testar sua AWS AppSync função usando o seguinte código:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
O manipulador de solicitação e resposta avaliado possui os dados do objeto de contexto de teste e o valor gerado de `util.autoId()`. Além disso, se você alterasse o `username` para um valor diferente de `Nadia`, os resultados não seriam retornados pois a verificação de autorização falharia. Para obter mais informações sobre o controle de acesso refinado, consulte [Casos de uso de autorização](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Testando manipuladores de solicitações e respostas com's AWS AppSync APIs
Você pode usar o comando API do `EvaluateCode` para testar remotamente seu código com dados simulados. Para começar a usar o comando, certifique-se de ter adicionado a permissão `appsync:evaluateMappingCode` à sua política. Por exemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Você pode aproveitar o comando usando o [AWS CLI](https://aws.amazon.com/cli/)ou [AWS SDKs](https://aws.amazon.com/tools/). Por exemplo, veja o `Dog` esquema e seus manipuladores de solicitação e resposta de AWS AppSync função da seção anterior. Usando a CLI em sua estação local, salve o código em um arquivo chamado `code.js` e salve o objeto `context` em um arquivo chamado `context.json`. No seu shell, execute o seguinte comando:
```
$ aws appsync evaluate-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
A resposta tem um `evaluationResult` contendo a carga retornada pelo seu manipulador. Também contém um objeto `logs` que contém a lista de logs que foram gerados pelo seu manipulador durante a avaliação. Isso facilita a depuração da execução do código e a visualização de informações sobre sua avaliação para ajudar na solução de problemas. Por exemplo:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
O `evaluationResult` pode ser analisado como JSON, que fornece:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Usando o SDK, você pode incorporar facilmente testes do seu conjunto de testes favorito para validar o comportamento dos seus manipuladores. Recomendamos a criação de testes usando o [Estrutura de trabalho de teste Jest](https://jestjs.io/), mas qualquer conjunto de testes funciona. O trecho a seguir mostra uma execução de validação hipotética. Esperamos que a resposta de avaliação seja um JSON válido, por isso, usamos `JSON.parse` para recuperar o JSON da resposta da string:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Isso produz o seguinte resultado:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
## Depuração de uma consulta atual
Não há substituto para um end-to-end teste e um registro para depurar um aplicativo de produção. AWS AppSync permite que você registre erros e detalhes completos da solicitação usando a Amazon CloudWatch. Além disso, você pode usar o AWS AppSync console para testar consultas, mutações e assinaturas do GraphQL e transmitir ao vivo os dados de log de cada solicitação de volta ao editor de consultas para depuração em tempo real. Para assinaturas, os logs exibem as informações do tempo de conexão.
Para fazer isso, você precisa ter CloudWatch os registros da Amazon habilitados com antecedência, conforme descrito em [Monitoramento e registro](monitoring.md#aws-appsync-monitoring). Em seguida, no AWS AppSync console, escolha a guia **Consultas** e insira uma consulta GraphQL válida. Na seção inferior direita, clique e arraste a janela **Registros em log** para abrir a visualização de registros. No topo da página, escolha o ícone de seta de reprodução para executar a consulta do GraphQL. Em alguns instantes, os logs completos da solicitação e da resposta para a operação serão transmitidos para essa seção e você poderá visualizá-los no console.
# 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](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
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
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
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
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.
# Criação de consultas básicas (VTL)
**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/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.
------
# Como desabilitar modelos de mapeamento VTL com resolvedores diretos do Lambda (VTL)
**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/configuring-resolvers-js.html).
Com resolvedores Lambda diretos, você pode contornar o uso de modelos de mapeamento VTL ao usar fontes de dados. AWS Lambda AWS AppSync pode fornecer uma carga padrão para sua função Lambda, bem como uma tradução padrão da resposta de uma função Lambda para um tipo GraphQL. Você pode optar por fornecer um modelo de solicitação, um modelo de resposta ou nenhum dos dois e AWS AppSync tratará isso adequadamente.
Para saber mais sobre a carga útil padrão da solicitação e a tradução de respostas que AWS AppSync fornece, consulte a referência do resolvedor do [Direct Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers). Para obter mais informações sobre como configurar uma fonte de AWS Lambda dados e configurar uma política de confiança do IAM, consulte [Anexar uma fonte de dados](attaching-a-data-source.md).
## Configurar resolvedores diretos do Lambda
As seções a seguir mostrarão como anexar fontes de dados do Lambda e adicionar resolvedores do Lambda aos seus campos.
### Adicionar uma fonte de dados do Lambda
Antes de ativar os resolvedores diretos do Lambda, você deve adicionar uma fonte de dados do Lambda.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, selecione **Fontes de dados**.
1. Escolha **Criar fonte de dados**.
1. Para **Nome da fonte de dados**, digite um nome para sua fonte de dados, como **myFunction**.
1. Para **Tipo de fonte de dados**, escolha a opção **Função AWS Lambda **.
1. Para **Região**, escolha a região apropriada.
1. Para **Função ARN**, escolha a função do Lambda na lista suspensa. Você pode pesquisar o nome da função ou inserir manualmente o ARN da função que deseja usar.
1. Crie um perfil do IAM (recomendado) ou escolha uma função existente que tenha permissão `lambda:invokeFunction` do IAM. Os perfis existentes precisam de uma política de confiança, conforme explicado na seção [Anexar uma fonte de dados](attaching-a-data-source.md).
Veja a seguir um exemplo de política do IAM que tem as permissões necessárias para executar as operações no recurso:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "lambda:invokeFunction" ],
"Resource": [
"arn:aws:lambda:us-west-2:123456789012:function:myFunction",
"arn:aws:lambda:us-west-2:123456789012:function:myFunction:*"
]
}
]
}
```
------
1. Selecione o botão **Criar**.
------
#### [ CLI ]
1. Crie um objeto da fonte de dados executando o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-data-source.html).
Você precisará digitar 4 parâmetros para esse comando específico:
1. O `api-id` da sua API.
1. O `name` da sua fonte de dados. No exemplo do console, esse é o **Nome da fonte de dados**.
1. O `type` da fonte de dados. No exemplo do console, isso é **função AWS Lambda **.
1. O `lambda-config`, que é o **ARN da função** no exemplo do console.
**nota**
Existem outros parâmetros, como `Region`, que devem ser configurados, mas geralmente usam como padrão os valores de configuração da CLI.
Veja um exemplo de comando:
```
aws appsync create-data-source --api-id abcdefghijklmnopqrstuvwxyz --name myFunction --type AWS_LAMBDA --lambda-config lambdaFunctionArn=arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"dataSource": {
"dataSourceArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/datasources/myFunction",
"type": "AWS_LAMBDA",
"name": "myFunction",
"lambdaConfig": {
"lambdaFunctionArn": "arn:aws:lambda:us-west-2:102847592837:function:appsync-lambda-example"
}
}
}
```
1. Para modificar os atributos de uma fonte de dados, execute o comando [https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/update-data-source.html).
Com exceção do `api-id` parâmetro, os parâmetros usados no comando `create-data-source` serão substituídos pelos novos valores do comando `update-data-source`.
------
### Ativar resolvedores diretos do Lambda
Depois de criar uma fonte de dados Lambda e configurar a função apropriada do IAM AWS AppSync para permitir a invocação da função, você pode vinculá-la a uma função de resolução ou pipeline.
------
#### [ Console ]
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. Na janela **Resolvedores**, selecione um campo ou operação e selecione o botão **Anexar**.
1. Na página **Criar novo resolvedor**, escolha a função do Lambda na lista suspensa.
1. Para aproveitar os resolvedores diretos do Lambda, confirme se os modelos de mapeamento de solicitação e resposta estão desativados na seção **Configurar modelos de mapeamento**.
1. Selecione o botão **Salvar resolvedor**.
------
#### [ CLI ]
+ 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 no seu esquema.
1. O `field-name` do campo no seu esquema.
1. O `data-source-name`, ou o nome da sua função do Lambda.
1. O `request-mapping-template`, que é o corpo da solicitação. No exemplo do console, desabilitamos o seguinte:
```
" "
```
1. O `response-mapping-template`, que é o corpo da resposta. No exemplo do console, o seguinte também foi desabilitado:
```
" "
```
Veja um exemplo de comando:
```
aws appsync create-resolver --api-id abcdefghijklmnopqrstuvwxyz --type-name Subscription --field-name onCreateTodo --data-source-name LambdaTest --request-mapping-template " " --response-mapping-template " "
```
Uma saída será retornada na CLI. Veja um exemplo abaixo:
```
{
"resolver": {
"resolverArn": "arn:aws:appsync:us-west-2:102847592837:apis/abcdefghijklmnopqrstuvwxyz/types/Subscription/resolvers/onCreateTodo",
"typeName": "Subscription",
"kind": "UNIT",
"fieldName": "onCreateTodo",
"dataSourceName": "LambdaTest"
}
}
```
------
Quando você desativa seus modelos de mapeamento, há vários comportamentos adicionais que ocorrerão no AWS AppSync:
+ Ao desativar um modelo de mapeamento, você está sinalizando AWS AppSync que aceita as traduções de dados padrão especificadas na referência do resolvedor do Direct [Lambda](resolver-mapping-template-reference-lambda.md#direct-lambda-resolvers).
+ Ao desativar o modelo de mapeamento de solicitações, sua fonte de dados do Lambda receberá uma payload que consiste em todo o objeto [Contexto](resolver-context-reference.md).
+ Ao desativar o modelo de mapeamento de resposta, o resultado da sua invocação do Lambda será traduzido de acordo com a versão do modelo de mapeamento da solicitação ou se o modelo de mapeamento da solicitação também estiver desativado.
# Testando e depurando resolvedores em (VTL) AWS AppSync
**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/configuring-resolvers-js.html).
AWS AppSync executa resolvedores em um campo GraphQL em relação a uma fonte de dados. Conforme descrito na [Visão geral do modelo de mapeamento do resolvedor](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview), os resolvedores se comunicam com as fontes de dados usando uma linguagem de modelos. Isso permite personalizar o comportamento e aplicar lógica e condições antes e depois de se comunicar com a fonte de dados. Para obter um guia de programação introdutório no estilo tutorial para programar resolvedores, consulte o [Guia de programação do modelo de mapeamento do resolvedor](resolver-mapping-template-reference-programming-guide.md#aws-appsync-resolver-mapping-template-reference-programming-guide).
Para ajudar os desenvolvedores a escrever, testar e depurar esses resolvedores, o AWS AppSync console também fornece ferramentas para criar uma solicitação e uma resposta do GraphQL com dados simulados até o resolvedor de campo individual. Além disso, você pode realizar consultas, mutações e assinaturas no AWS AppSync console e ver um stream de log detalhado da Amazon CloudWatch de toda a solicitação. Isso inclui os resultados de uma fonte de dados.
## Testes com dados simulados
Quando um resolvedor do GraphQL é invocado, ele contém um objeto `context` que contém informações sobre a solicitação. Isso inclui argumentos de um cliente, informações de identidade e dados do campo pai do GraphQL. Ele também contém os resultados da fonte de dados, que podem ser usados no modelo da resposta. Para obter mais informações sobre essa estrutura e os utilitários auxiliares disponíveis para o uso ao programar, consulte a [Referência de contexto do modelo de mapeamento do resolvedor](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).
Ao escrever ou editar um resolvedor, você pode passar um objeto de *contexto simulado* ou de *teste* para o editor do console. Isso permite ver como os modelos de solicitação e resposta avaliam, sem realmente executar segundo uma fonte de dados. Por exemplo, você pode enviar um argumento `firstname: Shaggy` de teste e ver como ele avalia ao usar `$ctx.args.firstname` no código do modelo. Você também pode testar a avaliação de qualquer utilitário auxiliar, como `$util.autoId()` ou `util.time.nowISO8601()`.
### Teste de resolvedores
Este exemplo usará o AWS AppSync console para testar os resolvedores.
1. Faça login no Console de gerenciamento da AWS e abra o [AppSyncconsole](https://console.aws.amazon.com/appsync/).
1. No **APIs painel**, escolha sua API GraphQL.
1. Na **barra lateral**, escolha **Esquema**.
1. Se ainda não tiver feito isso, no tipo e ao lado do campo, escolha **Anexar** para adicionar seu resolvedor.
Para obter mais informações sobre como construir um resolvedor completo, consulte [Configuração de resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/configuring-resolvers.html).
Caso contrário, selecione o resolvedor que já está no campo.
1. Na parte superior da página **Editar resolvedor**, escolha **Selecionar contexto de teste** e escolha **Criar novo contexto**.
1. Selecione um objeto de contexto de amostra ou preencha o JSON manualmente na janela **Contexto de execução**.
1. Insira um **Nome de contexto de texto**.
1. Clique no botão **Salvar**.
1. Na parte superior da página **Editar resolvedor**, escolha **Executar teste**.
Como exemplo mais prático, digamos que você tenha um aplicativo que armazena um tipo do GraphQL `Dog` que usa a geração automática de ID para objetos e os armazena no Amazon DynamoDB. Você também deseja gravar alguns valores dos argumentos de uma mutação do GraphQL e permitir que apenas usuários específicos vejam uma resposta. Veja a seguir a possível aparência do esquema:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Ao adicionar um resolvedor para a mutação `addDog`, preencha um objeto de contexto como o exemplo a seguir. Ele tem argumentos do cliente de `name` e `age`, e um `username` preenchido no objeto `identity`:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
Você pode testar isso usando os seguintes modelos de mapeamento da solicitação e da resposta:
**Modelo de solicitação**
```
{
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "$util.autoId()" }
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
**Modelo da resposta**
```
#if ($context.identity.username == "Nadia")
$util.toJson($ctx.result)
#else
$util.unauthorized()
#end
```
O modelo avaliado tem os dados do objeto de contexto de teste e o valor gerado de `$util.autoId()`. Além disso, se você alterasse o `username` para um valor diferente de `Nadia`, os resultados não seriam retornados pois a verificação de autorização falharia. Para obter mais informações sobre o controle de acesso refinado, consulte [Casos de uso de autorização](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).
### Testando modelos de mapeamento com AWS AppSync APIs
Você pode usar o comando da API `EvaluateMappingTemplate` para testar remotamente seus modelos de mapeamento com dados simulados. Para começar a usar o comando, certifique-se de ter adicionado a permissão `appsync:evaluateMappingTemplate` à sua política. Por exemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateMappingTemplate",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Você pode aproveitar o comando usando o [AWS CLI](https://aws.amazon.com/cli/)ou [AWS SDKs](https://aws.amazon.com/tools/). Por exemplo, veja o `Dog` esquema e seus modelos de request/response mapeamento da seção anterior. Usando a CLI em sua estação local, salve o modelo de solicitação em um arquivo chamado `request.vtl` e salve o objeto `context` em um arquivo chamado `context.json`. No seu shell, execute o seguinte comando:
```
aws appsync evaluate-mapping-template --template file://request.vtl --context file://context.json
```
O comando retorna a seguinte resposta:
```
{
"evaluationResult": "{\n \"version\" : \"2017-02-28\",\n \"operation\" : \"PutItem\",\n \"key\" : {\n \"id\" : { \"S\" : \"afcb4c85-49f8-40de-8f2b-248949176456\" }\n },\n \"attributeValues\" : {\"firstname\":{\"S\":\"Shaggy\"},\"age\":{\"N\":4}}\n}\n"
}
```
O `evaluationResult` contém os resultados do teste do modelo fornecido com o `context` fornecido. Você também pode testar seus modelos usando AWS SDKs o. Aqui está um exemplo usando o AWS SDK para JavaScript V2:
```
const AWS = require('aws-sdk')
const client = new AWS.AppSync({ region: 'us-east-2' })
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
client
.evaluateMappingTemplate({ template, context })
.promise()
.then((data) => console.log(data))
```
Usando o SDK, você pode incorporar facilmente testes do seu conjunto de testes favorito para validar o comportamento do seu modelo. Recomendamos a criação de testes usando o [Estrutura de trabalho de teste Jest](https://jestjs.io/), mas qualquer conjunto de testes funciona. O trecho a seguir mostra uma execução de validação hipotética. Esperamos que a resposta de avaliação seja um JSON válido, por isso, usamos `JSON.parse` para recuperar o JSON da resposta da string:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
test('request correctly calls DynamoDB', async () => {
const template = fs.readFileSync('./request.vtl', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateMappingTemplate({ template, context }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Isso produz o seguinte resultado:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 total
Time: 1.511 s, estimated 2 s
```
## Depuração de uma consulta atual
Não há substituto para um end-to-end teste e um registro para depurar um aplicativo de produção. AWS AppSync permite que você registre erros e detalhes completos da solicitação usando a Amazon CloudWatch. Além disso, você pode usar o AWS AppSync console para testar consultas, mutações e assinaturas do GraphQL e transmitir ao vivo os dados de log de cada solicitação de volta ao editor de consultas para depuração em tempo real. Para assinaturas, os logs exibem as informações do tempo de conexão.
Para fazer isso, você precisa ter CloudWatch os registros da Amazon habilitados com antecedência, conforme descrito em [Monitoramento e registro](monitoring.md#aws-appsync-monitoring). Em seguida, no AWS AppSync console, escolha a guia **Consultas** e insira uma consulta GraphQL válida. Na seção inferior direita, clique e arraste a janela **Registros em log** para abrir a visualização de registros. No topo da página, escolha o ícone de seta de reprodução para executar a consulta do GraphQL. Em alguns instantes, os logs completos da solicitação e da resposta para a operação serão transmitidos para essa seção e você poderá visualizá-los no console.
# Configurando e usando resolvedores de pipeline em AWS AppSync (VTL)
**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/configuring-resolvers-js.html).
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.
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](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview) para obter mais informações.
## 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 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
1. Função validateEmail
1. Função saveUser
1. 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.
## Etapa 2: 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 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.
Na página da nova função, escolha **Ações** e, em seguida, **Atualizar runtime**. Escolha `VTL` e, em seguida, **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**.
## 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 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**.
## 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: "nadia@myvaliddomain.com"
username: "nadia"
}) {
id
email
}
}
```
Ela deve retornar algo semelhante a:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"email": "nadia@myvaliddomain.com"
}
}
}
```
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](tutorial-pipeline-resolvers.md#aws-appsync-tutorial-pipeline-resolvers)