As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Criação de um aplicativo de postagem simples usando resolvedores do DynamoDB JavaScript
Neste tutorial, você importará suas tabelas do Amazon DynamoDB e as conectará AWS AppSync para criar uma API GraphQL totalmente funcional usando resolvedores de pipeline que você pode JavaScript utilizar em seu próprio aplicativo.
Você usará o AWS AppSync console para provisionar seus recursos do Amazon DynamoDB, criar seus resolvedores e conectá-los às suas fontes de dados. Você também poderá ler e gravar em seu banco de dados do Amazon DynamoDB por meio de instruções do GraphQL e assinar dados em tempo real.
Existem etapas específicas que devem ser concluídas para que as instruções do GraphQL sejam traduzidas para operações do Amazon DynamoDB e para que as respostas sejam traduzidas novamente para o GraphQL. Esse tutorial descreve o processo de configuração por meio de vários cenários reais e padrões de acesso aos dados.
## Criação da API GraphQL
**Para criar uma API GraphQL no AWS AppSync**
1. Abra o AppSync console e escolha **Criar API**.
1. Selecione **Design do zero** e escolha **Próximo**.
1. Nomeie sua API `PostTutorialAPI` e escolha **Próximo**. Vá para a página de revisão, mantendo o restante das opções definidas com seus valores padrão e escolha `Create`.
O AWS AppSync console cria uma nova API GraphQL para você. Por padrão, ele está usando o modo de autenticação de chave de API. Você pode usar o console para configurar o restante da API GraphQL e executar consultas nela durante o restante desse tutorial.
## Definição de uma API Post básica
Agora que você tem sua API GraphQL, você pode configurar um esquema básico que permite a criação, recuperação e exclusão básica de dados publicados.
**Para adicionar dados ao seu esquema**
1. Na sua API, escolha a guia **Esquema**.
1. Criaremos um esquema que define um tipo `Post` e uma operação `addPost` para adicionar e obter objetos `Post`. No painel **Esquema**, substitua o conteúdo pelo seguinte código:
```
schema {
query: Query
mutation: Mutation
}
type Query {
getPost(id: ID): Post
}
type Mutation {
addPost(
id: ID!
author: String!
title: String!
content: String!
url: String!
): Post!
}
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
}
```
1. Escolha **Salvar esquema**.
## Configuração de sua tabela do Amazon DynamoDB
O AWS AppSync console pode ajudar a provisionar os AWS recursos necessários para armazenar seus próprios recursos em uma tabela do Amazon DynamoDB. Nesta etapa, você criará uma tabela do Amazon DynamoDB, para armazenar suas postagens. Você também configurará um [índice secundário](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/SecondaryIndexes.html) que usaremos posteriormente.
**Para criar sua tabela do Amazon DynamoDB**
1. Na página **Esquema**, escolha **Criar recursos**.
1. Escolha **Usar tipo existente** e depois o tipo `Post`.
1. Na seção **Índices adicionais**, escolha **Adicionar índice**.
1. Nomeie o índice `author-index`.
1. Defina `Primary key` como `author` e a chave `Sort` como `None`.
1. Desative **Automatically generate GraphQL**. Neste exemplo, nós mesmos criaremos o resolvedor.
1. Escolha **Criar**.
Agora você tem uma nova fonte de dados chamada `PostTable`, que pode ser vista em **Fontes de dados** na guia lateral. Você usará essa fonte de dados para vincular suas consultas e mutações à sua tabela do Amazon DynamoDB.
## Configurando um resolvedor AddPost (Amazon DynamoDB) PutItem
Agora que conhece AWS AppSync a tabela do Amazon DynamoDB, você pode vinculá-la a consultas e mutações individuais definindo resolvedores. O primeiro resolvedor que você cria é o resolvedor de `addPost` pipeline usando JavaScript, que permite criar uma publicação na sua tabela do Amazon DynamoDB. Um resolvedor de pipeline possui os seguintes componentes:
+ A local no esquema do GraphQL para anexar o resolvedor. Nesse caso, você está configurando um resolvedor no campo `createPost` no tipo `Mutation`. Esse resolvedor será invocado quando o chamador chamar a mutação `{ addPost(...){...} }`.
+ A fonte de dados a ser usada para esse resolvedor. Nesse caso, você deseja usar a fonte de dados do DynamoDB definida anteriormente para poder adicionar entradas à tabela do DynamoDB de `post-table-for-tutorial`.
+ O manipulador de solicitações. O manipulador de solicitações é uma função que manipula a solicitação recebida do chamador e a traduz em instruções para AWS AppSync execução no DynamoDB.
+ O manipulador de respostas. A tarefa do manipulador de respostas é manipular a resposta do DynamoDB e traduzi-la de volta em algo que o GraphQL espera. Isso é útil se a forma dos dados no DynamoDB for diferente para o tipo `Post` no GraphQL, mas, nesse caso, elas têm a mesma forma, portanto basta transmitir os dados.
**Para configurar seu resolvedor**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Resolvedores**, encontre o campo `addPost` no tipo `Mutation` e depois escolha **Anexar**.
1. Escolha sua fonte de dados e selecione **Criar**.
1. No seu editor de código, substitua o código por este trecho:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 }
const key = { id: ctx.args.id ?? util.autoId() }
return ddb.put({ key, item })
}
export function response(ctx) {
return ctx.result
}
```
1. Escolha **Salvar**.
**nota**
Nesse código, você usa os utilitários do módulo do DynamoDB que permitem criar facilmente solicitações do DynamoDB.
AWS AppSync vem com um utilitário para geração automática de ID chamado`util.autoId()`, que é usado para gerar um ID para sua nova postagem. Se você não especificar uma ID, o utilitário a gerará automaticamente para você.
```
const key = { id: ctx.args.id ?? util.autoId() }
```
Para obter mais informações sobre os utilitários disponíveis para JavaScript, consulte [recursos de JavaScript tempo de execução para resolvedores e](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) funções.
### Chamar a API para adicionar uma publicação
Agora que o resolvedor foi configurado, é AWS AppSync possível traduzir uma `addPost` mutação recebida em uma operação do Amazon DynamoDB. `PutItem` Agora você pode executar uma mutação para colocar algo na tabela.
**Para executar a operação**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação:
```
mutation addPost {
addPost(
id: 123,
author: "AUTHORNAME"
title: "Our first post!"
content: "This is our first post."
url: "https://aws.amazon.com/appsync/"
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `addPost`. Os resultados da publicação recém-criada devem aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"addPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
A explicação a seguir mostra o que ocorreu:
1. AWS AppSync recebeu uma solicitação de `addPost` mutação.
1. AWS AppSync executa o manipulador de solicitações do resolvedor. A função `ddb.put` cria uma solicitação `PutItem` semelhante a esta:
```
{
operation: 'PutItem',
key: { id: { S: '123' } },
attributeValues: {
downs: { N: 0 },
author: { S: 'AUTHORNAME' },
ups: { N: 1 },
title: { S: 'Our first post!' },
version: { N: 1 },
content: { S: 'This is our first post.' },
url: { S: 'https://aws.amazon.com/appsync/' }
}
}
```
1. AWS AppSync usa esse valor para gerar e executar uma solicitação do Amazon `PutItem` DynamoDB.
1. AWS AppSync pegou os resultados da `PutItem` solicitação e os converteu de volta em tipos GraphQL.
```
{
"id" : "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups" : 1,
"downs" : 0,
"version" : 1
}
```
1. O manipulador de resposta retorna o resultado imediatamente (`return ctx.result`).
1. O resultado final é visível na resposta do GraphQL.
## Configuração do resolvedor GetPost (Amazon DynamoDB) GetItem
Agora que você pode adicionar dados à tabela do Amazon DynamoDB, é necessário configurar a consulta `getPost` para que ela possa recuperar esses dados da tabela. Para fazer isso, vamos configurar outro resolvedor.
**Para adicionar seu resolvedor**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `getPost` no tipo `Query` e escolha **Anexar**.
1. Escolha sua fonte de dados e selecione **Criar**.
1. No editor de código, substitua o código por este trecho:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({ key: { id: ctx.args.id } })
}
export const response = (ctx) => ctx.result
```
1. Salve o resolvedor.
**nota**
Nesse resolvedor, usamos uma expressão de função de seta para o manipulador de resposta.
### Chamar a API para obter uma publicação
Agora que o resolvedor foi configurado, AWS AppSync sabe como traduzir uma `getPost` consulta recebida em uma operação do Amazon DynamoDB`GetItem`. Agora é possível executar uma consulta para recuperar a publicação criada anteriormente.
**Para executar sua consulta**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione o seguinte código e use a ID que você copiou após criar sua publicação:
```
query getPost {
getPost(id: "123") {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `getPost`. Os resultados da publicação recém-criada devem aparecer no painel **Resultados** à direita do painel **Consultas**.
1. A publicação recuperada do Amazon DynamoDB deve aparecer no painel **Results** à direita do painel **Queries**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"getPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our first post!",
"content": "This is our first post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
Como alternativa, utilize o exemplo a seguir:
```
query getPost {
getPost(id: "123") {
id
author
title
}
}
```
Se sua consulta `getPost` precisar apenas de `id`, `author` e `title`, você poderá alterar sua função de solicitação para usar expressões de projeção para especificar apenas os atributos que deseja da tabela do DynamoDB para evitar transferência desnecessária de dados do DynamoDB para AWS AppSync. Por exemplo, a função de solicitação pode se parecer com o trecho abaixo:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({
key: { id: ctx.args.id },
projection: ['author', 'id', 'title'],
})
}
export const response = (ctx) => ctx.result
```
Você também pode usar um [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js)com `getPost` para representar`expression`:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.'))
return ddb.get({ key: { id: ctx.args.id }, projection })
}
export const response = (ctx) => ctx.result
```
## Crie uma mutação UpdatePost (Amazon DynamoDB) UpdateItem
Até agora, você pode criar e recuperar objetos `Post` no Amazon DynamoDB. Depois, você configurará uma nova mutação para atualizar um objeto. Em comparação com a mutação `addPost` que exige que todos os campos sejam especificados, essa mutação permite especificar apenas os campos que deseja alterar. Também introduziu um novo argumento `expectedVersion` que permite especificar a versão que deseja modificar. Você configurará uma condição que garante que você esteja modificando a versão mais recente do objeto. Você fará isso usando o Operation.sc do Amazon DynamoDB `UpdateItem`
**Para criar seu resolvedor**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Schema**, modifique o tipo `Mutation` para adicionar uma nova mutação `updatePost` da seguinte forma:
```
type Mutation {
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
id: ID
author: String!
title: String!
content: String!
url: String!
): Post!
}
```
1. Escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `updatePost`recém-criado no tipo `Mutation` e escolha **Anexar**. Crie seu resolvedor usando o trecho abaixo:
```
import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { id, expectedVersion, ...rest } = ctx.args;
const values = Object.entries(rest).reduce((obj, [key, value]) => {
obj[key] = value ?? ddb.operations.remove();
return obj;
}, {});
return ddb.update({
key: { id },
condition: { version: { eq: expectedVersion } },
update: { ...values, version: ddb.operations.increment(1) },
});
}
export function response(ctx) {
const { error, result } = ctx;
if (error) {
util.appendError(error.message, error.type);
}
return result;
```
1. Salve todas as alterações feitas.
Esse resolvedor usa `ddb.update` para criar uma solicitação `UpdateItem` do Amazon DynamoDB. Em vez de escrever o item inteiro, você está apenas pedindo ao Amazon DynamoDB para atualizar determinados atributos. Isso é feito usando expressões de atualização do Amazon DynamoDB.
A função `ddb.update` recebe uma chave e um objeto de atualização como argumentos. Depois, você verifica os valores dos argumentos recebidos. Quando um valor é definido como `null`, use a operação `remove` do DynamoDB para sinalizar que o valor deve ser removido do item do DynamoDB.
Existe também uma nova seção `condition`. Uma expressão de condição permite que você diga ao AWS AppSync Amazon DynamoDB se a solicitação deve ou não ser bem-sucedida com base no estado do objeto que já está no Amazon DynamoDB antes da execução da operação. Nesse caso, você deseja que a solicitação `UpdateItem` seja bem-sucedida apenas se o campo `version` do item atualmente no Amazon DynamoDB corresponder exatamente ao argumento `expectedVersion`. Quando o item é atualizado, queremos incrementar o valor de `version`. Isso é fácil de fazer com a função de operação `increment`.
Para obter mais informações sobre expressões de condição, consulte a documentação de [expressões de condição](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions).
Para obter mais informações sobre a `UpdateItem` solicitação, consulte a [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)documentação e a documentação do módulo [DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html).
Para obter mais informações sobre como escrever expressões de atualização, consulte a documentação do [ UpdateExpressionsDynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html).
### Chamar a API para atualizar uma publicação
Vamos tentar atualizar o objeto `Post` com o novo resolvedor.
**Para atualizar seu objeto**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente:
```
mutation updatePost {
updatePost(
id:123
title: "An empty story"
content: null
expectedVersion: 1
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `updatePost`.
1. A publicação atualizada no Amazon DynamoDB deve aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"updatePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 2
}
}
}
```
Nessa solicitação, você pediu ao AWS AppSync Amazon DynamoDB que atualizasse somente `title` os campos e. `content` Todos os outros campos foram ignorados (exceto o incremento do campo `version`). Definiu-se o atributo `title` para um novo valor e o atributo `content` foi removido da publicação. Os campos `author`, `url`, `ups` e `downs` foram mantidos. Tente executar a solicitação de mutação novamente, deixando a solicitação exatamente como está. Você verá uma resposta semelhante à seguinte:
```
{
"data": {
"updatePost": null
},
"errors": [
{
"path": [
"updatePost"
],
"data": null,
"errorType": "DynamoDB:ConditionalCheckFailedException",
"errorInfo": null,
"locations": [
{
"line": 2,
"column": 3,
"sourceName": null
}
],
"message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)"
}
]
}
```
A solicitação falha porque a expressão da condição é avaliada como `false`:
1. Na primeira vez que você executou a solicitação, o valor do campo `version` da publicação no Amazon DynamoDB era `1`, que correspondia ao argumento `expectedVersion`. A solicitação foi bem-sucedida, o que significa que o campo `version` foi incrementado no Amazon DynamoDB para `2`.
1. Na segunda vez que a solicitação foi executada, o valor do campo `version` da publicação no Amazon DynamoDB era `2`, que não correspondeu ao argumento `expectedVersion`.
Esse padrão é geralmente chamado de *bloqueio positivo*.
## Crie mutações de votos (Amazon DynamoDB) UpdateItem
O tipo `Post` contém campos `ups` e `downs` para permitir o registro de votos positivos e negativos. Contudo, no momento, a API não nos permite fazer nada com eles. Vamos adicionar uma mutação para permitir votos positivos e negativos nas publicações.
**Para adicionar sua mutação**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Esquema**, modifique o tipo `Mutation` e adicione o enumerador `DIRECTION` para adicionar novas mutações de voto:
```
type Mutation {
vote(id: ID!, direction: DIRECTION!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
id: ID,
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
enum DIRECTION {
UP
DOWN
}
```
1. Escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `vote`recém-criado no tipo `Mutation` e escolha **Anexar**. Crie um resolvedor criando e substituindo o código pelo seguinte trecho:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const field = ctx.args.direction === 'UP' ? 'ups' : 'downs';
return ddb.update({
key: { id: ctx.args.id },
update: {
[field]: ddb.operations.increment(1),
version: ddb.operations.increment(1),
},
});
}
export const response = (ctx) => ctx.result;
```
1. Salve todas as alterações feitas.
### Chamar a API para realizar voto positivo e negativo em uma publicação
Agora que os novos resolvedores foram configurados, AWS AppSync sabe como traduzir uma entrada `upvotePost` ou uma `downvote` mutação em uma operação do Amazon DynamoDB. `UpdateItem` Agora é possível executar mutações para realizar votos positivos ou negativos na publicação criada anteriormente.
**Para executar sua mutação**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente:
```
mutation votePost {
vote(id:123, direction: UP) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `votePost`.
1. A publicação atualizada no Amazon DynamoDB deve aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"vote": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 0,
"version": 4
}
}
}
```
1. Escolha **Executar** mais algumas vezes. Você deverá ver os campos `ups` e `version` aumentando em `1` cada vez que executar a consulta.
1. Altere a consulta para chamá-la com um arquivo `DIRECTION`.
```
mutation votePost {
vote(id:123, direction: DOWN) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `votePost`.
Desta vez, você deverá ver os campos `downs` e `version` aumentando em `1` cada vez que executar a consulta.
## Configurando um resolvedor DeletePost (Amazon DynamoDB) DeleteItem
Depois, talvez você deseje criar uma mutação para excluir uma publicação. Você fará isso usando a operação `DeleteItem` do Amazon DynamoDB.
**Para adicionar sua mutação**
1. Em seu esquema, escolha a guia **Esquema**.
1. No painel **Esquema**, modifique o tipo `Mutation` para adicionar uma nova mutação `deletePost`:
```
type Mutation {
deletePost(id: ID!, expectedVersion: Int): Post
vote(id: ID!, direction: DIRECTION!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
id: ID
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
1. Desta vez, você tornou o campo `expectedVersion` opcional. Depois, escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `delete`recém-criado no tipo `Mutation` e escolha **Anexar**. Crie um resolvedor usando o seguinte código:
```
import { util } from '@aws-appsync/utils'
import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
let condition = null;
if (ctx.args.expectedVersion) {
condition = {
or: [
{ id: { attributeExists: false } },
{ version: { eq: ctx.args.expectedVersion } },
],
};
}
return ddb.remove({ key: { id: ctx.args.id }, condition });
}
export function response(ctx) {
const { error, result } = ctx;
if (error) {
util.appendError(error.message, error.type);
}
return result;
}
```
**nota**
O argumento `expectedVersion` é opcional. Se o chamador definir um argumento `expectedVersion` na solicitação, o manipulador de solicitação adiciona uma condição que permite que a solicitação `DeleteItem` seja bem-sucedida somente se o item já estiver excluído ou se o atributo `version` da publicação no Amazon DynamoDB corresponder exatamente ao `expectedVersion`. Se omitido, nenhuma expressão de condição será especificada na solicitação `DeleteItem`. Ele será bem-sucedida independentemente do valor de `version`, ou se o item existe ou não no Amazon DynamoDB.
Mesmo que você esteja excluindo um item, é possível retornar o item que foi excluído, caso ainda não tenha sido excluído.
Para obter mais informações sobre a `DeleteItem` solicitação, consulte a [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)documentação.
### Chamar a API para excluir uma publicação
Agora que o resolvedor foi configurado, AWS AppSync sabe como traduzir uma `delete` mutação recebida em uma operação do Amazon DynamoDB. `DeleteItem` Agora você pode executar uma mutação para excluir algo na tabela.
**Para executar sua mutação**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente:
```
mutation deletePost {
deletePost(id:123) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `deletePost`.
1. A publicação foi excluída do Amazon DynamoDB. **Observe que AWS AppSync retorna o valor do item que foi excluído do Amazon DynamoDB, que deve aparecer no painel Resultados **à** direita do painel Consultas.** A aparência deve ser semelhante à seguinte:
```
{
"data": {
"deletePost": {
"id": "123",
"author": "A new author",
"title": "An empty story",
"content": null,
"url": "https://aws.amazon.com/appsync/",
"ups": 6,
"downs": 4,
"version": 12
}
}
}
```
1. O valor só será retornado se essa chamada para `deletePost` for aquela que realmente o exclui do Amazon DynamoDB. Escolha **Executar** novamente.
1. A chamada ainda será bem-sucedida, mas nenhum valor é retornado:
```
{
"data": {
"deletePost": null
}
}
```
1. Agora vamos tentar excluir uma publicação, mas dessa vez especificando um `expectedValue`. Primeiro é necessário criar uma nova publicação, pois você acabou de excluir aquela com a qual estava trabalhando.
1. No painel **Consultas**, adicione a seguinte mutação:
```
mutation addPost {
addPost(
id:123
author: "AUTHORNAME"
title: "Our second post!"
content: "A new post."
url: "https://aws.amazon.com/appsync/"
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `addPost`.
1. Os resultados da publicação recém-criada devem aparecer no painel **Resultados** à direita do painel **Consultas**. Registre a `id` do objeto recém-criado porque você precisará dele em alguns instantes. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"addPost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our second post!",
"content": "A new post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
1. Agora, vamos tentar excluir essa publicação com um valor ilegal para **expectedVersion**. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente:
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 9999
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `deletePost`. O seguinte resultado é retornado:
```
{
"data": {
"deletePost": null
},
"errors": [
{
"path": [
"deletePost"
],
"data": null,
"errorType": "DynamoDB:ConditionalCheckFailedException",
"errorInfo": null,
"locations": [
{
"line": 2,
"column": 3,
"sourceName": null
}
],
"message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)"
}
]
}
```
1. A solicitação falhou porque a expressão da condição foi avaliada como `false`. O valor para `version` da publicação no Amazon DynamoDB não corresponde ao `expectedValue` especificado nos argumentos. O valor atual do objeto é retornada no campo `data` na seção `errors` da resposta do GraphQL. Repita a solicitação, mas corrija o `expectedVersion`:
```
mutation deletePost {
deletePost(
id:123
expectedVersion: 1
) {
id
author
title
content
url
ups
downs
version
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `deletePost`.
Dessa vez, a solicitação é bem-sucedida e o valor que foi excluído do Amazon DynamoDB é retornado:
```
{
"data": {
"deletePost": {
"id": "123",
"author": "AUTHORNAME",
"title": "Our second post!",
"content": "A new post.",
"url": "https://aws.amazon.com/appsync/",
"ups": 1,
"downs": 0,
"version": 1
}
}
}
```
1. Escolha **Executar** novamente. A chamada ainda é bem-sucedida, mas dessa vez nenhum valor é retornado porque a publicação já estava excluída no Amazon DynamoDB.
```
{ "data": { "deletePost": null } }
```
## Configurar o resolvedor allPost (Scan do Amazon DynamoDB)
Até agora, a API só será útil se você souber o `id` de cada publicação a ser examinada. Vamos adicionar um novo resolvedor que retornará todas as publicações na tabela.
**Para adicionar sua mutação**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Esquema**, modifique o tipo `Query` para adicionar uma nova consulta `allPost` da seguinte forma:
```
type Query {
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
1. Adicione um novo tipo `PaginationPosts`:
```
type PaginatedPosts {
posts: [Post!]!
nextToken: String
}
```
1. Escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `allPost`recém-criado no tipo `Query` e escolha **Anexar**. Crie um resolvedor com o seguinte código:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken } = ctx.arguments;
return ddb.scan({ limit, nextToken });
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
O manipulador de solicitações desse resolvedor espera dois argumentos opcionais:
+ `limit` - Especifica o número máximo de itens a serem retornados em uma única chamada.
+ `nextToken` - Usado para recuperar o próximo conjunto de resultados (mostraremos de onde vem o valor `nextToken` mais tarde).
1. Salve todas as alterações feitas no seu resolvedor.
Para obter mais informações sobre solicitação `Scan`, consulte a documentação de referência do [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan).
### Chamar a API para verificar todas as publicações
Agora que o resolvedor foi configurado, AWS AppSync sabe como traduzir uma `allPost` consulta recebida em uma operação do Amazon DynamoDB`Scan`. Agora você pode verificar a tabela para recuperar todas as publicações. No entanto, antes de testar, é necessário preencher a tabela com alguns dados, pois tudo que foi usado até agora já foi excluído.
**Para adicionar e consultar dados **
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação:
```
mutation addPost {
post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
}
```
1. Escolha **Executar** (o botão de reprodução laranja).
1. Agora vamos examinar a tabela, retornando cinco resultados por vez. No painel **Consultas**, cole a seguinte consulta:
```
query allPost {
allPost(limit: 5) {
posts {
id
title
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPost`.
As primeiras cinco publicações devem aparecer no painel **Results** à direita do painel **Queries**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPost": {
"posts": [
{
"id": "5",
"title": "A series of posts, Volume 5"
},
{
"id": "1",
"title": "A series of posts, Volume 1"
},
{
"id": "6",
"title": "A series of posts, Volume 6"
},
{
"id": "9",
"title": "A series of posts, Volume 9"
},
{
"id": "7",
"title": "A series of posts, Volume 7"
}
],
"nextToken": ""
}
}
}
```
1. Você recebeu cinco resultados e um `nextToken` que pode ser usado para obter o próximo conjunto de resultados. Atualize a consulta `allPost` para incluir o `nextToken` do conjunto de resultados anterior:
```
query allPost {
allPost(
limit: 5
nextToken: ""
) {
posts {
id
author
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPost`.
As quatro publicações restantes devem aparecer no painel **Results** à direita do painel **Queries**. Não há `nextToken` nesse conjunto de resultados pois todos os nove resultados foram encontrados, sem nenhum restante. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPost": {
"posts": [
{
"id": "2",
"title": "A series of posts, Volume 2"
},
{
"id": "3",
"title": "A series of posts, Volume 3"
},
{
"id": "4",
"title": "A series of posts, Volume 4"
},
{
"id": "8",
"title": "A series of posts, Volume 8"
}
],
"nextToken": null
}
}
}
```
## Configurando um resolvedor de allPostsBy autor (Amazon DynamoDB Query)
Além de verificar todas as publicações do Amazon DynamoDB, também é possível consultar o Amazon DynamoDB para recuperar as publicações criadas por um determinado autor. A tabela do Amazon DynamoDB que você criou anteriormente já tem um `GlobalSecondaryIndex` chamado `author-index` que pode ser usada com uma operação `Query` do Amazon DynamoDB para recuperar todas as publicações criadas por um autor específico.
**Para adicionar sua consulta**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Esquema**, modifique o tipo `Query` para adicionar uma nova consulta `allPostsByAuthor` da seguinte forma:
```
type Query {
allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
Observe que isso usa o mesmo tipo `PaginatedPosts` usado na consulta `allPost`.
1. Escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `allPostsByAuthor`recém-criado no tipo `Query` e escolha **Anexar**. Crie um resolvedor usando o trecho abaixo:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken, author } = ctx.arguments;
return ddb.query({
index: 'author-index',
query: { author: { eq: author } },
limit,
nextToken,
});
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Assim como o resolvedor `allPost`, esse resolvedor possui dois argumentos opcionais:
+ `limit` - Especifica o número máximo de itens a serem retornados em uma única chamada.
+ `nextToken` - Recupera o próximo conjunto de resultados (o valor `nextToken` pode ser obtido em uma chamada anterior).
1. Salve todas as alterações feitas no seu resolvedor.
Para obter mais informações sobre a solicitação `Query`, consulte a documentação de referência da [consulta](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-query).
### Chamar a API para consultar todas as publicações por autor
Agora que o resolvedor foi configurado, AWS AppSync sabe como traduzir uma `allPostsByAuthor` mutação recebida em uma operação do DynamoDB em relação ao índice`Query`. `author-index` Agora você pode consultar a tabela para recuperar todas as publicações de um determinado autor.
Antes disso, no entanto, vamos preencher a tabela com mais algumas publicações pois até agora todas têm o mesmo autor.
**Para adicionar dados e consultar**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, adicione a seguinte mutação:
```
mutation addPost {
post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title }
post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title }
post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title }
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `addPost`.
1. Agora, vamos consultar a tabela, retornando todas as publicações de autoria da `Nadia`. No painel **Consultas**, cole a seguinte consulta:
```
query allPostsByAuthor {
allPostsByAuthor(author: "Nadia") {
posts {
id
title
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPostsByAuthor`. Todas as publicações de autoria de `Nadia` devem aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you know...?"
}
],
"nextToken": null
}
}
}
```
1. A paginação funciona para `Query` da mesma forma que funciona para `Scan`. Por exemplo, vamos procurar todas as publicações por `AUTHORNAME`, obtendo cinco por vez.
1. No painel **Consultas**, cole a seguinte consulta:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
limit: 5
) {
posts {
id
title
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPostsByAuthor`. Todas as publicações de autoria de `AUTHORNAME` devem aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "6",
"title": "A series of posts, Volume 6"
},
{
"id": "4",
"title": "A series of posts, Volume 4"
},
{
"id": "2",
"title": "A series of posts, Volume 2"
},
{
"id": "7",
"title": "A series of posts, Volume 7"
},
{
"id": "1",
"title": "A series of posts, Volume 1"
}
],
"nextToken": ""
}
}
}
```
1. Atualize o argumento `nextToken` com o valor retornado pela consulta anterior da seguinte forma:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "AUTHORNAME"
limit: 5
nextToken: ""
) {
posts {
id
title
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPostsByAuthor`. As publicações restantes de autoria de `AUTHORNAME` devem aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "8",
"title": "A series of posts, Volume 8"
},
{
"id": "5",
"title": "A series of posts, Volume 5"
},
{
"id": "3",
"title": "A series of posts, Volume 3"
},
{
"id": "9",
"title": "A series of posts, Volume 9"
}
],
"nextToken": null
}
}
}
```
## Uso de conjuntos
Até esse ponto, o `Post` tipo era um key/value objeto plano. Também é possível modelar objetos complexos com seu resolvedor, como conjuntos, listas e mapas. Vamos atualizar o tipo `Post` para incluir tags. Uma publicação pode ter zero ou mais tags, que são armazenadas no DynamoDB como um Conjunto de strings. Vamos configurar também algumas mutações para adicionar e remover tags, e uma nova consulta para verificar as publicações com uma tag específica.
**Para configurar seus dados**
1. Na sua API, escolha a guia **Esquema**.
1. No painel **Esquema**, modifique o tipo `Post` para adicionar um novo campo `tags` da seguinte forma:
```
type Post {
id: ID!
author: String
title: String
content: String
url: String
ups: Int!
downs: Int!
version: Int!
tags: [String!]
}
```
1. No painel **Esquema**, modifique o tipo `Query` para adicionar uma nova consulta `allPostsByTag` da seguinte forma:
```
type Query {
allPostsByTag(tag: String!, limit: Int, nextToken: String): PaginatedPosts!
allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
allPost(limit: Int, nextToken: String): PaginatedPosts!
getPost(id: ID): Post
}
```
1. No painel **Esquema**, modifique o tipo `Mutation` para adicionar novas mutações `addTag` e `removeTag` da seguinte forma:
```
type Mutation {
addTag(id: ID!, tag: String!): Post
removeTag(id: ID!, tag: String!): Post
deletePost(id: ID!, expectedVersion: Int): Post
upvotePost(id: ID!): Post
downvotePost(id: ID!): Post
updatePost(
id: ID!,
author: String,
title: String,
content: String,
url: String,
expectedVersion: Int!
): Post
addPost(
author: String!,
title: String!,
content: String!,
url: String!
): Post!
}
```
1. Escolha **Salvar esquema**.
1. No painel **Resolvedores** à direita, encontre o campo `allPostsByTag`recém-criado no tipo `Query` e escolha **Anexar**. Crie seu resolvedor usando o trecho abaixo:
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 20, nextToken, tag } = ctx.arguments;
return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } });
}
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
1. Salve todas as alterações feitas no seu resolvedor.
1. Agora, faça o mesmo para o campo `Mutation` `addTag` usando o trecho abaixo:
**nota**
Embora os utilitários do DynamoDB atualmente não sejam compatíveis com operações de conjuntos, você ainda pode interagir com os conjuntos criando a solicitação sozinho.
```
import { util } from '@aws-appsync/utils'
export function request(ctx) {
const { id, tag } = ctx.arguments
const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 })
expressionValues[':tags'] = util.dynamodb.toStringSet([tag])
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: `ADD tags :tags, version :plusOne`,
expressionValues,
},
}
}
export const response = (ctx) => ctx.result
```
1. Salve todas as alterações feitas no seu resolvedor.
1. Repita isso mais uma vez para o campo `Mutation` `removeTag` usando o trecho abaixo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, tag } = ctx.arguments;
const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 });
expressionValues[':tags'] = util.dynamodb.toStringSet([tag]);
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: `DELETE tags :tags ADD version :plusOne`,
expressionValues,
},
};
}
export const response = (ctx) => ctx.resultexport
```
1. Salve todas as alterações feitas no seu resolvedor.
### Chamar a API para trabalhar com tags
Agora que você configurou os resolvedores, AWS AppSync sabe como traduzir as entradas `addTag` e as `allPostsByTag` solicitações em DynamoDB e operações. `removeTag` `UpdateItem` `Scan` Para testar, vamos selecionar uma das publicações criadas anteriormente. Por exemplo, vamos usar uma publicação de autoria da `Nadia`.
**Para usar tags**
1. Na sua API, escolha a guia **Consultas**.
1. No painel **Consultas**, cole a seguinte consulta:
```
query allPostsByAuthor {
allPostsByAuthor(
author: "Nadia"
) {
posts {
id
title
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPostsByAuthor`.
1. Todas as publicações de Nadia devem aparecer no painel **Resultados** à direita do painel **Consultas**. A aparência deve ser semelhante à seguinte:
```
{
"data": {
"allPostsByAuthor": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world"
},
{
"id": "11",
"title": "Did you known...?"
}
],
"nextToken": null
}
}
}
```
1. Vamos usar aquela com o título *The cutest dog in the world*. Registre sua `id` porque você a usará mais tarde. Agora, vamos tentar adicionar uma tag `dog`.
1. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente.
```
mutation addTag {
addTag(id:10 tag: "dog") {
id
title
tags
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `addTag`. A publicação é atualizada com a nova tag:
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
1. É possível adicionar mais tags. Atualize a mutação para alterar o argumento `tag` para `puppy`:
```
mutation addTag {
addTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `addTag`. A publicação é atualizada com a nova tag:
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
}
}
```
1. Também é possível excluir tags. No painel **Consultas**, adicione a seguinte mutação. Também será necessário atualizar o argumento `id` para o valor anotado anteriormente:
```
mutation removeTag {
removeTag(id:10 tag: "puppy") {
id
title
tags
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `removeTag`. A publicação é atualizada e a tag `puppy` é excluída.
```
{
"data": {
"addTag": {
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog"
]
}
}
}
```
1. Também é possível pesquisar todas as publicações com uma tag. No painel **Consultas**, cole a seguinte consulta:
```
query allPostsByTag {
allPostsByTag(tag: "dog") {
posts {
id
title
tags
}
nextToken
}
}
```
1. Escolha **Executar** (o botão de reprodução laranja) e selecione `allPostsByTag`. Todos as publicações com a tag `dog` são retornadas da seguinte forma:
```
{
"data": {
"allPostsByTag": {
"posts": [
{
"id": "10",
"title": "The cutest dog in the world",
"tags": [
"dog",
"puppy"
]
}
],
"nextToken": null
}
}
}
```
## Conclusão
Neste tutorial, você criou uma API que permite manipular objetos `Post` no DynamoDB usando AWS AppSync e GraphQL.
Para limpar, você pode excluir a API AWS AppSync GraphQL do console.
Para excluir a função associada à tabela do DynamoDB, selecione sua fonte de dados na tabela **Fontes de dados** e clique em **editar**. Observe o valor da função em **Criar ou usar uma função existente**. Acesse o console do IAM, para excluir a função.
Para excluir sua tabela do DynamoDB, clique no nome da tabela na lista de fontes de dados. Isso leva você ao console do DynamoDB, onde você pode excluir a tabela.