Criação de um aplicativo de postagem simples usando resolvedores do DynamoDB JavaScript

Modo de foco

Criação de um aplicativo de postagem simples usando resolvedores do DynamoDB JavaScript - AWS AppSync GraphQL

Criação da API GraphQL Definição de uma API Post básica Configuração de sua tabela do Amazon DynamoDB Configurando um resolvedor AddPost (Amazon DynamoDB) PutItem Configuração do resolvedor GetPost (Amazon DynamoDB) GetItem Crie uma mutação UpdatePost (Amazon DynamoDB) UpdateItem Crie mutações de votos (Amazon DynamoDB) UpdateItem Configurando um resolvedor DeletePost (Amazon DynamoDB) DeleteItem Configurar o resolvedor allPost (Scan do Amazon DynamoDB)Configurando um resolvedor de allPostsBy autor (Amazon DynamoDB Query)Uso de conjuntos Conclusão

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

Abra o AppSync console e escolha Criar API.
Selecione Design do zero e escolha Próximo.
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

Na sua API, escolha a guia Esquema.

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!
}

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 que usaremos posteriormente.

Para criar sua tabela do Amazon DynamoDB

Na página Esquema, escolha Criar recursos.
Escolha Usar tipo existente e depois o tipo Post.
Na seção Índices adicionais, escolha Adicionar índice.
Nomeie o índice author-index.
Defina Primary key como author e a chave Sort como None.
Desative Automatically generate GraphQL. Neste exemplo, nós mesmos criaremos o resolvedor.
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

Na sua API, escolha a guia Esquema.
No painel Resolvedores, encontre o campo addPost no tipo Mutation e depois escolha Anexar.
Escolha sua fonte de dados e selecione Criar.

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
}

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

Na sua API, escolha a guia Consultas.

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
  }
}

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:

AWS AppSync recebeu uma solicitação de addPost mutação.

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/' }
  }
}

AWS AppSync usa esse valor para gerar e executar uma solicitação do Amazon PutItem DynamoDB.

AWS AppSync pegou os resultados da PutItem solicitação e os converteu novamente 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
}

O manipulador de resposta retorna o resultado imediatamente (return ctx.result).
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

Na sua API, escolha a guia Esquema.
No painel Resolvedores à direita, encontre o campo getPost no tipo Query e escolha Anexar.
Escolha sua fonte de dados e selecione Criar.

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

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 DynamoDBGetItem. Agora é possível executar uma consulta para recuperar a publicação criada anteriormente.

Para executar sua consulta

Na sua API, escolha a guia Consultas.

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
  }
}

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.

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 selectionSetListcom getPost para representarexpression:


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

Na sua API, escolha a guia Esquema.

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!
}

Escolha Salvar esquema.

No painel Resolvedores à direita, encontre o campo updatePostrecé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;

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.

Para obter mais informações sobre a UpdateItem solicitação, consulte a UpdateItemdocumentação e a documentação do módulo DynamoDB.

Para obter mais informações sobre como escrever expressões de atualização, consulte a documentação do UpdateExpressionsDynamoDB.

Chamar a API para atualizar uma publicação

Vamos tentar atualizar o objeto Post com o novo resolvedor.

Para atualizar seu objeto

Na sua API, escolha a guia Consultas.

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
  }
}

Escolha Executar (o botão de reprodução laranja) e selecione updatePost.

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:

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

Na sua API, escolha a guia Esquema.

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
}

Escolha Salvar esquema.

No painel Resolvedores à direita, encontre o campo voterecé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;

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

Na sua API, escolha a guia Consultas.

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
  }
}

Escolha Executar (o botão de reprodução laranja) e selecione votePost.

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
    }
  }
}

Escolha Executar mais algumas vezes. Você deverá ver os campos ups e version aumentando em 1 cada vez que executar a consulta.

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
  }
}

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

Em seu esquema, escolha a guia Esquema.

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!
}

Desta vez, você tornou o campo expectedVersion opcional. Depois, escolha Salvar esquema.
No painel Resolvedores à direita, encontre o campo deleterecé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 DeleteItemdocumentaçã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

Na sua API, escolha a guia Consultas.

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
  }
}

Escolha Executar (o botão de reprodução laranja) e selecione deletePost.

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
    }
  }
}

O valor só será retornado se essa chamada para deletePost for aquela que realmente o exclui do Amazon DynamoDB. Escolha Executar novamente.
A chamada ainda será bem-sucedida, mas nenhum valor é retornado:
```
{
  "data": {
    "deletePost": null
  }
}
```
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.

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
  }
}

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

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
  }
}
```

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)"
    }
  ]
}

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
  }
}
```

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
    }
  }
}

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

Na sua API, escolha a guia Esquema.

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
}

Adicione um novo tipo PaginationPosts:


type PaginatedPosts {
    posts: [Post!]!
    nextToken: String
}

Escolha Salvar esquema.
No painel Resolvedores à direita, encontre o campo allPostrecé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).
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.

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

Na sua API, escolha a guia Consultas.

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 }
}

Escolha Executar (o botão de reprodução laranja).

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
  }
}

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": "<token>"
    }
  }
}

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: "<token>"
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}
```

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

Na sua API, escolha a guia Esquema.

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.

Escolha Salvar esquema.

No painel Resolvedores à direita, encontre o campo allPostsByAuthorrecé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).

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.

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 índiceQuery. 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

Na sua API, escolha a guia Consultas.

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 }
}

Escolha Executar (o botão de reprodução laranja) e selecione addPost.

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
  }
}

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
    }
  }
}

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.

No painel Consultas, cole a seguinte consulta:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

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": "<token>"
    }
  }
}

Atualize o argumento nextToken com o valor retornado pela consulta anterior da seguinte forma:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

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é agora, o tipo Post foi um objeto de chave/valor 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

Na sua API, escolha a guia Esquema.

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!]
}

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
}

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!
}

Escolha Salvar esquema.

No painel Resolvedores à direita, encontre o campo allPostsByTagrecé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 };
}

Salve todas as alterações feitas no seu resolvedor.

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

Salve todas as alterações feitas no seu resolvedor.

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

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

Na sua API, escolha a guia Consultas.

No painel Consultas, cole a seguinte consulta:


query allPostsByAuthor {
  allPostsByAuthor(
    author: "Nadia"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

Escolha Executar (o botão de reprodução laranja) e selecione allPostsByAuthor.

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
    }
  }
}

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.
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
  }
}
```

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"
      ]
    }
  }
}

É 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
  }
}

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"
      ]
    }
  }
}

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
  }
}
```

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"
      ]
    }
  }
}

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
  }
}

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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

JavaScript tutoriais de resolvedores

Usando AWS Lambda resolvedores

Próximo tópico:

Usando AWS Lambda resolvedores

Tópico anterior:

JavaScript tutoriais de resolvedores

Precisa de ajuda?

Nesta página

Esta página foi útil?

Fornecer feedback

Privacidade Termos do site Preferências de cookies

Selecione suas preferências de cookies

Personalizar preferências de cookies

Essenciais

Desempenho

Funcionais

Publicidade

Não foi possível salvar as preferências de cookie

Criação de um aplicativo de postagem simples usando resolvedores do DynamoDB JavaScript

Criação da API GraphQL

Definição de uma API Post básica

Configuração de sua tabela do Amazon DynamoDB

Configurando um resolvedor AddPost (Amazon DynamoDB) PutItem

nota

Chamar a API para adicionar uma publicação

Configuração do resolvedor GetPost (Amazon DynamoDB) GetItem

nota

Chamar a API para obter uma publicação

Crie uma mutação UpdatePost (Amazon DynamoDB) UpdateItem

Chamar a API para atualizar uma publicação

Crie mutações de votos (Amazon DynamoDB) UpdateItem

Chamar a API para realizar voto positivo e negativo em uma publicação

Configurando um resolvedor DeletePost (Amazon DynamoDB) DeleteItem

nota

Chamar a API para excluir uma publicação

Configurar o resolvedor allPost (Scan do Amazon DynamoDB)

Chamar a API para verificar todas as publicações

Configurando um resolvedor de allPostsBy autor (Amazon DynamoDB Query)

Chamar a API para consultar todas as publicações por autor

Uso de conjuntos

nota

Chamar a API para trabalhar com tags

Conclusão

Próximo tópico:

Tópico anterior:

Precisa de ajuda?

Nesta página

Esta página foi útil?

Selecione suas preferências de cookies

Criação de um aplicativo de postagem simples usando resolvedores do DynamoDB JavaScript

Criação da API GraphQL

Definição de uma API Post básica

Configuração de sua tabela do Amazon DynamoDB

Configurando um resolvedor AddPost (Amazon DynamoDB) PutItem

nota

Chamar a API para adicionar uma publicação

Configuração do resolvedor GetPost (Amazon DynamoDB) GetItem

nota

Chamar a API para obter uma publicação

Crie uma mutação UpdatePost (Amazon DynamoDB) UpdateItem

Chamar a API para atualizar uma publicação

Crie mutações de votos (Amazon DynamoDB) UpdateItem

Chamar a API para realizar voto positivo e negativo em uma publicação

Configurando um resolvedor DeletePost (Amazon DynamoDB) DeleteItem

nota

Chamar a API para excluir uma publicação

Configurar o resolvedor allPost (Scan do Amazon DynamoDB)

Chamar a API para verificar todas as publicações

Configurando um resolvedor de allPostsBy autor (Amazon DynamoDB Query)

Chamar a API para consultar todas as publicações por autor​

Uso de conjuntos

nota

Chamar a API para trabalhar com tags

Conclusão

Próximo tópico:

Tópico anterior:

Precisa de ajuda?

Nesta página

Esta página foi útil?

Chamar a API para consultar todas as publicações por autor