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á.
# AWS AppSync JavaScript referência da função de resolução para o DynamoDB
A função AWS AppSync DynamoDB permite que você use o [GraphQL](https://graphql.org) para armazenar e recuperar dados em tabelas existentes do Amazon DynamoDB em sua conta mapeando uma solicitação de entrada do GraphQL em uma chamada do DynamoDB e, em seguida, mapeando a resposta do DynamoDB de volta para o GraphQL. Esta seção descreve os manipuladores de solicitação e resposta para as operações do DynamoDB compatíveis:
+ [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-getitem.html)- A GetItem solicitação permite que você instrua a função do DynamoDB a fazer uma GetItem solicitação ao DynamoDB e permite especificar a chave do item no DynamoDB e se deve usar uma leitura consistente ou não.
+ [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-putitem.html)- O documento de mapeamento de solicitações permite que você PutItem solicite à função do DynamoDB que faça uma PutItem solicitação ao DynamoDB e especifique a chave do item no DynamoDB, o conteúdo completo do item (composto por valores de chave e atributos) e condições para que a operação seja bem-sucedida.
+ [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-updateitem.html)- A UpdateItem solicitação permite que você peça à função do DynamoDB que faça uma UpdateItem solicitação ao DynamoDB e especifique a chave do item no DynamoDB, uma expressão de atualização descrevendo como atualizar o item no DynamoDB e as condições para que a operação seja bem-sucedida.
+ [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-deleteitem.html)- A DeleteItem solicitação permite que você solicite à função do DynamoDB que faça uma DeleteItem solicitação ao DynamoDB e especifique a chave do item no DynamoDB e as condições para que a operação seja bem-sucedida.
+ [Query](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-query.html): o objeto de solicitação Query permite orientar o resolvedor do DynamoDB a fazer uma solicitação Query ao DynamoDB, além de especificar a expressão de chave, qual índice usar, filtros adicionais, quantos itens retornar, se deve usar leituras consistentes, direção da consulta (para a frente ou para trás) e tokens de paginação.
+ [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-scan.html): a solicitação Scan permite orientar a função do DynamoDB a fazer uma solicitação Scan ao DynamoDB, além de especificar um filtro para excluir resultados, qual índice usar, quantos itens retornar, se deve usar leituras consistentes, tokens de paginação e verificações paralelas.
+ [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-sync.html): o objeto Sync permite recuperar todos os resultados de uma tabela do DynamoDB e, depois, receber apenas os dados alterados desde a última consulta (as atualizações delta). As solicitações Sync só podem ser feitas a fontes de dados versionadas do DynamoDB. Você pode especificar um filtro para excluir resultados, quantos itens devolver, tokens de paginação e quando sua última operação de sincronização foi iniciada.
+ [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-get-item.html)- O objeto de BatchGetItem solicitação permite que você peça à função do DynamoDB que faça uma BatchGetItem solicitação ao DynamoDB para recuperar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar os nomes das tabelas das quais recuperar os itens e as chaves dos itens a serem recuperados de cada tabela.
+ [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-delete-item.html)- O objeto de BatchDeleteItem solicitação permite que você peça à função do DynamoDB que faça uma BatchWriteItem solicitação ao DynamoDB para excluir vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar os nomes das tabelas das quais excluir os itens e as chaves dos itens a serem excluídos de cada tabela.
+ [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-put-item.html)- O objeto de BatchPutItem solicitação permite que você peça à função do DynamoDB que faça uma BatchWriteItem solicitação ao DynamoDB para colocar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar os nomes das tabelas nas quais colocar os itens e os itens completos a serem colocados em cada tabela.
+ [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-get-items.html)- O objeto de TransactGetItems solicitação permite que você peça à função do DynamoDB que faça uma TransactGetItems solicitação ao DynamoDB para recuperar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o nome da tabela de cada item de solicitação do qual recuperar o item e a chave de cada item a ser recuperado de cada tabela.
+ [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- O objeto de TransactWriteItems solicitação permite que você peça à função do DynamoDB que faça uma TransactWriteItems solicitação ao DynamoDB para gravar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o nome da tabela de destino de cada item de solicitação, a operação de cada item a ser executada e a chave de cada item a ser gravada.
+ [Sistema de tipos (mapeamento de solicitações)](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-typed-values-request.html) - Saiba mais sobre como a digitação do DynamoDB é integrada às solicitações. AWS AppSync
+ [Sistema de tipos (mapeamento de respostas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-typed-values-responses.html): saiba mais sobre como os tipos do DynamoDB são convertidos automaticamente em GraphQL ou JSON em uma carga útil de resposta.
+ [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-filter.html): saiba mais sobre filtros para operações de consulta e verificação.
+ [Expressões condicionais](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-condition-expressions.html) - Saiba mais sobre expressões condicionais para PutItem UpdateItem, e DeleteItem operações.
+ [Expressões de condição de transação](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions.html) - Saiba mais sobre expressões de condição para TransactWriteItems operações.
+ [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-projections.html): saiba mais sobre como especificar atributos em operações de leitura.
# GetItem
A `GetItem` solicitação permite que você instrua a função do AWS AppSync DynamoDB a fazer uma `GetItem` solicitação ao DynamoDB e permite que você especifique:
+ A chave do item no DynamoDB
+ Se deve usar uma leitura consistente ou não
A solicitação `GetItem` tem a seguinte estrutura:
```
type DynamoDBGetItem = {
operation: 'GetItem';
key: { [key: string]: any };
consistentRead?: ConsistentRead;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Os campos são definidos da seguinte forma:
## GetItem campos
### GetItem lista de campos
**`operation`**
A operação do DynamoDB para execução. Para executar a operação `GetItem` do DynamoDB, ela deve ser definida como `GetItem`. Este valor é obrigatório.
**`key`**
A chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
**`consistentRead`**
Se deve ou não realizar uma leitura altamente consistente com o DynamoDB. Isso é opcional e usa como padrão `false`.
**`projection`**
Uma projeção usada para especificar os atributos a serem retornados da operação do DynamoDB. Para obter mais informações sobre projeções, consulte [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Esse campo é opcional.
O item retornado do DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
## Exemplo
O exemplo a seguir é um manipulador de solicitação de função para uma consulta `getThing(foo: String!, bar: String!)` GraphQL:
```
export function request(ctx) {
const {foo, bar} = ctx.args
return {
operation : "GetItem",
key : util.dynamodb.toMapValues({foo, bar}),
consistentRead : true
}
}
```
Para obter mais informações sobre a API `GetItem` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
# PutItem
O documento de mapeamento de solicitações permite que você `PutItem` solicite à função do AWS AppSync DynamoDB que faça uma `PutItem` solicitação ao DynamoDB e especifique o seguinte:
+ A chave do item no DynamoDB
+ O conteúdo completo do item (composto por `key` e `attributeValues`)
+ Condições para que a operação seja bem-sucedida
A solicitação `PutItem` tem a seguinte estrutura:
```
type DynamoDBPutItemRequest = {
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: any};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Os campos são definidos da seguinte forma:
## PutItem campos
### PutItem lista de campos
**`operation`**
A operação do DynamoDB para execução. Para executar a operação `PutItem` do DynamoDB, ela deve ser definida como `PutItem`. Este valor é obrigatório.
**`key`**
A chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
**`attributeValues`**
O restante dos atributos do item a ser colocado no DynamoDB. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Esse campo é opcional.
**`condition`**
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, uma solicitação `PutItem` substitui qualquer entrada existente para esse item. Para obter mais informações sobre as condições, consulte [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). Este valor é opcional.
**`_version`**
Um valor numérico que representa a versão conhecida mais recente de um item. Este valor é opcional. Esse campo é usado para *Detecção de conflitos* e só é compatível com fontes de dados versionadas.
**`customPartitionKey`**
Quando ativado, esse valor de string modifica o formato dos `ds_pk` registros `ds_sk` e usados pela tabela de sincronização delta quando o controle de versão é ativado (para obter mais informações, consulte [Detecção e sincronização de conflitos no Guia](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) do *AWS AppSync desenvolvedor*). Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. Esse campo é opcional.
**`populateIndexFields`**
Um valor booleano que, quando ativado **com `customPartitionKey`**, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. Para obter mais informações, consulte [Detecção e sincronização de conflitos](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) no *Guia do desenvolvedor do AWS AppSync *. Esse campo é opcional.
O item gravado no DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
O item gravado no DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScriptresolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
## Exemplo 1
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `updateThing(foo: String!, bar: String!, name: String!, version: Int!)`:
Se nenhum item com a chave especificada existir, ele será criado. Se já existir um item com a chave especificada, ele será substituído.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Exemplo 2
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)`:
Esse exemplo verifica se o item que está atualmente no DynamoDB tem o campo `version` definido como `expectedVersion`.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, name, expectedVersion } = ctx.args;
const values = { name, version: expectedVersion + 1 };
let condition = util.transform.toDynamoDBConditionExpression({
version: { eq: expectedVersion },
});
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ foo, bar }),
attributeValues: util.dynamodb.toMapValues(values),
condition,
};
}
```
Para obter mais informações sobre a API `PutItem` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
# UpdateItem
A `UpdateItem` solicitação permite que você solicite à função do AWS AppSync DynamoDB que faça uma `UpdateItem` solicitação ao DynamoDB e especifique o seguinte:
+ A chave do item no DynamoDB
+ Uma expressão de atualização que descreve como atualizar o item no DynamoDB
+ Condições para que a operação seja bem-sucedida
A solicitação `UpdateItem` tem a seguinte estrutura:
```
type DynamoDBUpdateItemRequest = {
operation: 'UpdateItem';
key: { [key: string]: any };
update: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Os campos são definidos da seguinte forma:
## UpdateItem campos
### UpdateItem lista de campos
**`operation`**
A operação do DynamoDB para execução. Para executar a operação `UpdateItem` do DynamoDB, ela deve ser definida como `UpdateItem`. Este valor é obrigatório.
**`key`**
A chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (mapeamento da solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
**`update`**
A seção `update` permite especificar uma expressão de atualização que descreve como atualizar o item no DynamoDB. Para obter mais informações sobre como escrever expressões de atualização, consulte a documentação do [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta seção é obrigatória.
A seção `update` tem três componentes:
** `expression` **
A expressão de atualização. Este valor é obrigatório.
** `expressionNames` **
As substituições para espaços reservados de *nome* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de nome usado em `expression` e o valor deve ser uma string que corresponde ao nome do atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados em `expression`.
** `expressionValues` **
As substituições para espaços reservados de *valor* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na `expression` e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Isso deve ser especificado. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados em `expression`.
**`condition`**
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, a solicitação `UpdateItem` atualizará as entradas existentes independentemente do estado atual. Para obter mais informações sobre as condições, consulte [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). Este valor é opcional.
**`_version`**
Um valor numérico que representa a versão conhecida mais recente de um item. Este valor é opcional. Esse campo é usado para *Detecção de conflitos* e só é compatível com fontes de dados versionadas.
**`customPartitionKey`**
Quando ativado, esse valor de string modifica o formato dos `ds_pk` registros `ds_sk` e usados pela tabela de sincronização delta quando o controle de versão é ativado (para obter mais informações, consulte [Detecção e sincronização de conflitos no Guia](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) do *AWS AppSync desenvolvedor*). Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. Esse campo é opcional.
**`populateIndexFields`**
Um valor booleano que, quando ativado **com `customPartitionKey`**, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. Para obter mais informações, consulte [Detecção e sincronização de conflitos](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) no *Guia do desenvolvedor do AWS AppSync *. Esse campo é opcional.
O item atualizado no DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
## Exemplo 1
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `upvote(id: ID!)`:
Nesse exemplo, um item no DynamoDB tem seus campos `upvotes` e `version` incrementados por 1.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id } = ctx.args;
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: 'ADD #votefield :plusOne, version :plusOne',
expressionNames: { '#votefield': 'upvotes' },
expressionValues: { ':plusOne': { N: 1 } },
},
};
}
```
## Exemplo 2
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`:
Esse é um exemplo complexo que inspeciona os argumentos e gera dinamicamente a expressão de atualização que inclui apenas os argumentos que foram fornecidos pelo cliente. Por exemplo, se `title` e `author` são omitidos, eles não são atualizados. Se um argumento for especificado, mas o seu valor for `null`, esse campo é excluído do objeto no DynamoDB. Finalmente, a operação tem uma condição, que verifica se o item que está atualmente no DynamoDB tem o campo `version` definido como `expectedVersion`:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { args: { input: { id, ...values } } } = ctx;
const condition = {
id: { attributeExists: true },
version: { eq: values.expectedVersion },
};
values.expectedVersion += 1;
return dynamodbUpdateRequest({ keys: { id }, values, condition });
}
/**
* Helper function to update an item
* @returns an UpdateItem request
*/
function dynamodbUpdateRequest(params) {
const { keys, values, condition: inCondObj } = params;
const sets = [];
const removes = [];
const expressionNames = {};
const expValues = {};
// Iterate through the keys of the values
for (const [key, value] of Object.entries(values)) {
expressionNames[`#${key}`] = key;
if (value) {
sets.push(`#${key} = :${key}`);
expValues[`:${key}`] = value;
} else {
removes.push(`#${key}`);
}
}
let expression = sets.length ? `SET ${sets.join(', ')}` : '';
expression += removes.length ? ` REMOVE ${removes.join(', ')}` : '';
const condition = JSON.parse(
util.transform.toDynamoDBConditionExpression(inCondObj)
);
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues(keys),
condition,
update: {
expression,
expressionNames,
expressionValues: util.dynamodb.toMapValues(expValues),
},
};
}
```
Para obter mais informações sobre a API `UpdateItem` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
# DeleteItem
A `DeleteItem` solicitação permite que você instrua a função do AWS AppSync DynamoDB a fazer uma `DeleteItem` solicitação ao DynamoDB e permite que você especifique o seguinte:
+ A chave do item no DynamoDB
+ Condições para que a operação seja bem-sucedida
A solicitação `DeleteItem` tem a seguinte estrutura:
```
type DynamoDBDeleteItemRequest = {
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Os campos são definidos da seguinte forma:
## DeleteItem campos
### DeleteItem lista de campos
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `DeleteItem` do DynamoDB, ela deve ser definida como `DeleteItem`. Este valor é obrigatório.
** `key` **
A chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (mapeamento da solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
** `condition` **
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, a solicitação `DeleteItem` excluirá um item independentemente do estado atual. Para obter mais informações sobre as condições, consulte [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). Este valor é opcional.
** `_version` **
Um valor numérico que representa a versão conhecida mais recente de um item. Este valor é opcional. Esse campo é usado para *Detecção de conflitos* e só é compatível com fontes de dados versionadas.
**`customPartitionKey`**
Quando ativado, esse valor de string modifica o formato dos `ds_pk` registros `ds_sk` e usados pela tabela de sincronização delta quando o controle de versão é ativado (para obter mais informações, consulte [Detecção e sincronização de conflitos no Guia](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) do *AWS AppSync desenvolvedor*). Quando ativado, o processamento da entrada `populateIndexFields` também é ativado. Esse campo é opcional.
**`populateIndexFields`**
Um valor booleano que, quando ativado **com `customPartitionKey`**, cria novas entradas para cada registro na tabela de sincronização delta, especificamente nas colunas `gsi_ds_pk` e `gsi_ds_sk`. Para obter mais informações, consulte [Detecção e sincronização de conflitos](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) no *Guia do desenvolvedor do AWS AppSync *. Esse campo é opcional.
O item excluído do DynamoDB é automaticamente convertido nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
## Exemplo 1
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `deleteItem(id: ID!)`: Se existir um item com esse ID, ele será excluído.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
## Exemplo 2
O exemplo a seguir é um manipulador de solicitação de função para uma mutação GraphQL `deleteItem(id: ID!, expectedVersion: Int!)`: Se existir um item com esse ID, ele será excluído, mas apenas se o campo `version` estiver definido como `expectedVersion`:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, expectedVersion } = ctx.args;
const condition = {
id: { attributeExists: true },
version: { eq: expectedVersion },
};
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id }),
condition: util.transform.toDynamoDBConditionExpression(condition),
};
}
```
Para obter mais informações sobre a API `DeleteItem` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
# Consulta
O objeto de `Query` solicitação permite que você peça ao AWS AppSync resolvedor do DynamoDB que faça uma `Query` solicitação ao DynamoDB e permite que você especifique o seguinte:
+ Expressão chave
+ Qual índice usar
+ Qualquer filtro adicional
+ Quantos itens retornar
+ Se deve usar leituras consistentes
+ direção da consulta (para frente ou para trás)
+ Token de paginação
O objeto de solicitação `Query` tem a seguinte estrutura:
```
type DynamoDBQueryRequest = {
operation: 'Query';
query: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
index?: string;
nextToken?: string;
limit?: number;
scanIndexForward?: boolean;
consistentRead?: boolean;
select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'SPECIFIC_ATTRIBUTES';
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Os campos são definidos da seguinte forma:
## Campos de consulta
### Lista de campos de consulta
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `Query` do DynamoDB, ela deve ser definida como `Query`. Este valor é obrigatório.
** `query` **
A seção `query` permite especificar uma expressão de condição de chave que descreve quais itens recuperar do DynamoDB. Para obter mais informações sobre como escrever expressões de condição chave, consulte a documentação do [ KeyConditions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Essa seção deve ser especificada.
** `expression` **
A expressão da consulta. Esse campo deve ser especificado.
** `expressionNames` **
As substituições para espaços reservados de *nome* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de nome usado em `expression` e o valor deve ser uma string que corresponde ao nome do atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados em `expression`.
** `expressionValues` **
As substituições para espaços reservados de *valor* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na `expression` e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados em `expression`.
** `filter` **
Um filtro adicional que pode ser usado para filtrar os resultados do DynamoDB antes que sejam retornados. Para obter mais informações sobre os filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Esse campo é opcional.
** `index` **
O nome do índice para consulta. A operação de consulta do DynamoDB permite que você faça a varredura em Índices secundários locais e Índices secundários globais, além do índice de chave primária para uma chave de hash. Se especificado, isso informa o DynamoDB para consultar o índice especificado. Se omitido, o índice da chave primária será consultado.
** `nextToken` **
O token de paginação para continuar uma consulta anterior. Isso seria obtido de uma consulta anterior. Esse campo é opcional.
** `limit` **
O número máximo de itens a serem avaliados (não necessariamente o número de itens correspondentes). Esse campo é opcional.
** `scanIndexForward` **
Um booliano que indica se a consulta deve ser para frente ou para trás. Esse campo é opcional e usa como padrão `true`.
** `consistentRead` **
Um booleano que indica se deseja usar leituras consistentes ao consultar o DynamoDB. Esse campo é opcional e usa como padrão `false`.
** `select` **
Por padrão, o AWS AppSync resolvedor do DynamoDB retorna somente atributos que são projetados no índice. Se forem necessários mais atributos, você poderá definir esse campo. Esse campo é opcional. Os valores compatíveis são:
** `ALL_ATTRIBUTES` **
Retorna todos os atributos de item da tabela ou índice especificado. Se você consultar um índice secundário local, o DynamoDB buscará todo o item da tabela pai para cada item correspondente no índice. Se o índice estiver configurado para projetar todos os atributos de item, todos os dados podem ser obtidos no índice secundário local, e nenhuma busca será necessária.
** `ALL_PROJECTED_ATTRIBUTES` **
Permitido apenas ao consultar um índice. Recupera todos os atributos que foram projetados no índice. Se o índice estiver configurado para projetar todos os atributos, esse valor de retorno é equivalente a especificar `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Retorna somente os atributos listados em `expression` de `projection`. Esse valor de retorno é equivalente a especificar `expression` de `projection` sem especificar nenhum valor para `Select`.
**`projection`**
Uma projeção usada para especificar os atributos a serem retornados da operação do DynamoDB. Para obter mais informações sobre projeções, consulte [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Esse campo é opcional.
Os resultados do DynamoDB são automaticamente convertidos nos tipos primitivos GraphQL e JSON e estão disponíveis no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
Os resultados possuem a seguinte estrutura:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Os campos são definidos da seguinte forma:
** `items` **
Uma lista que contém os itens retornados pela consulta do DynamoDB.
** `nextToken` **
Se existirem mais resultados, `nextToken` conterá um token de paginação que você pode usar em outra solicitação. Observe que AWS AppSync criptografa e ofusca o token de paginação retornado do DynamoDB. Isso impede que os dados da sua tabela sejam divulgados inadvertidamente para o chamador. Observe também que esses tokens de paginação não podem ser usados em diferentes funções ou resolvedores.
** `scannedCount` **
O número de itens que corresponderam à expressão de condição da consulta, antes que uma expressão de filtro (se houve) fosse aplicada.
## Exemplo
O exemplo a seguir é um manipulador de solicitação de função para uma consulta `getPosts(owner: ID!)` GraphQL:
Nesse exemplo, um índice secundário global em uma tabela é consultado para retornar todas as postagens de propriedade do ID especificado.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { owner } = ctx.args;
return {
operation: 'Query',
query: {
expression: 'ownerId = :ownerId',
expressionValues: util.dynamodb.toMapValues({ ':ownerId': owner }),
},
index: 'owner-index',
};
}
```
Para obter mais informações sobre a API `Query` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).
# Verificar
A `Scan` solicitação permite que você instrua a função do AWS AppSync DynamoDB a fazer uma `Scan` solicitação ao DynamoDB e permite que você especifique o seguinte:
+ Um filtro para excluir os resultados
+ Qual índice usar
+ Quantos itens retornar
+ Se deve usar leituras consistentes
+ Token de paginação
+ Verificações paralelas
O objeto de solicitação `Scan` tem a seguinte estrutura:
```
type DynamoDBScanRequest = {
operation: 'Scan';
index?: string;
limit?: number;
consistentRead?: boolean;
nextToken?: string;
totalSegments?: number;
segment?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Os campos são definidos da seguinte forma:
## Verificar campos
### Lista de campos de verificação
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `Scan` do DynamoDB, ela deve ser definida como `Scan`. Este valor é obrigatório.
** `filter` **
Um filtro que pode ser usado para filtrar os resultados do DynamoDB antes que sejam retornados. Para obter mais informações sobre os filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Esse campo é opcional.
** `index` **
O nome do índice para consulta. A operação de consulta do DynamoDB permite que você faça a varredura em Índices secundários locais e Índices secundários globais, além do índice de chave primária para uma chave de hash. Se especificado, isso informa o DynamoDB para consultar o índice especificado. Se omitido, o índice da chave primária será consultado.
** `limit` **
O número máximo de itens a serem avaliados ao mesmo tempo. Esse campo é opcional.
** `consistentRead` **
Um booleano que indica se serão usadas leituras consistentes ao consultar o DynamoDB. Esse campo é opcional e usa como padrão `false`.
** `nextToken` **
O token de paginação para continuar uma consulta anterior. Isso seria obtido de uma consulta anterior. Esse campo é opcional.
** `select` **
Por padrão, a função AWS AppSync DynamoDB retorna somente os atributos projetados no índice. Se forem necessários mais atributos, esse campo pode ser definido. Esse campo é opcional. Os valores compatíveis são:
** `ALL_ATTRIBUTES` **
Retorna todos os atributos de item da tabela ou índice especificado. Se você consultar um índice secundário local, o DynamoDB buscará todo o item da tabela pai para cada item correspondente no índice. Se o índice estiver configurado para projetar todos os atributos de item, todos os dados podem ser obtidos no índice secundário local, e nenhuma busca será necessária.
** `ALL_PROJECTED_ATTRIBUTES` **
Permitido apenas ao consultar um índice. Recupera todos os atributos que foram projetados no índice. Se o índice estiver configurado para projetar todos os atributos, esse valor de retorno é equivalente a especificar `ALL_ATTRIBUTES`.
**`SPECIFIC_ATTRIBUTES`**
Retorna somente os atributos listados em `expression` de `projection`. Esse valor de retorno é equivalente a especificar `expression` de `projection` sem especificar nenhum valor para `Select`.
** `totalSegments` **
O número de segmentos para particionar a tabela ao executar uma verificação paralela. Esse campo é opcional, mas deve ser especificado se `segment` estiver especificado.
** `segment` **
O segmento da tabela nessa operação ao executar uma verificação paralela. Esse campo é opcional, mas deve ser especificado se `totalSegments` estiver especificado.
**`projection`**
Uma projeção usada para especificar os atributos a serem retornados da operação do DynamoDB. Para obter mais informações sobre projeções, consulte [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Esse campo é opcional.
Os resultados retornados pela verificação do DynamoDB são automaticamente convertidos nos tipos primitivos GraphQL e JSON e está disponível no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
Os resultados possuem a seguinte estrutura:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Os campos são definidos da seguinte forma:
** `items` **
Uma lista que contém os itens retornados pela verificação do DynamoDB.
** `nextToken` **
Se houver mais resultados, `nextToken` contém um token de paginação que você pode usar em outra solicitação. AWS AppSync criptografa e ofusca o token de paginação retornado do DynamoDB. Isso impede que os dados da sua tabela sejam divulgados inadvertidamente para o chamador. Além disso, esses tokens de paginação não podem ser usados em diferentes funções ou resolvedores.
** `scannedCount` **
O número de itens recuperados pelo DynamoDB antes da aplicação de uma expressão de filtro (se houver).
## Exemplo 1
O exemplo a seguir é um manipulador de solicitação de função para uma consulta `allPosts` GraphQL.
Nesse exemplo, todas as entradas na tabela são retornadas.
```
export function request(ctx) {
return { operation: 'Scan' };
}
```
## Exemplo 2
O exemplo a seguir é um manipulador de solicitação de função para uma consulta `postsMatching(title: String!)` GraphQL.
Nesse exemplo, todas as entradas na tabela são retornadas onde o título começa com o argumento `title`.
```
export function request(ctx) {
const { title } = ctx.args;
const filter = { filter: { beginsWith: title } };
return {
operation: 'Scan',
filter: JSON.parse(util.transform.toDynamoDBFilterExpression(filter)),
};
}
```
Para obter mais informações sobre a API `Scan` do DynamoDB, consulte a [Documentação da API do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).
# Sincronização
O objeto de solicitação `Sync` permite recuperar todos os resultados de uma tabela do DynamoDB e, depois, receber apenas os dados alterados desde a última consulta (as atualizações delta). As solicitações `Sync` só podem ser feitas para fontes de dados versionadas do DynamoDB. É possível especificar o seguinte:
+ Um filtro para excluir os resultados
+ Quantos itens retornar
+ Token de paginação
+ Quando sua última operação de `Sync` foi iniciada
O objeto de solicitação `Sync` tem a seguinte estrutura:
```
type DynamoDBSyncRequest = {
operation: 'Sync';
basePartitionKey?: string;
deltaIndexName?: string;
limit?: number;
nextToken?: string;
lastSync?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
};
```
Os campos são definidos da seguinte forma:
## Campos de sincronização
### Lista de campos de sincronização
** `operation` **
A operação do DynamoDB para execução. Para executar a operação do `Sync` do , isso deve ser definido para `Sync`. Este valor é obrigatório.
** `filter` **
Um filtro que pode ser usado para filtrar os resultados do DynamoDB antes que sejam retornados. Para obter mais informações sobre os filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Esse campo é opcional.
** `limit` **
O número máximo de itens a serem avaliados ao mesmo tempo. Esse campo é opcional. Se omitido, o limite padrão será definido como `100` itens. O valor máximo para esse campo é de `1000` itens.
** `nextToken` **
O token de paginação para continuar uma consulta anterior. Isso seria obtido de uma consulta anterior. Esse campo é opcional.
** `lastSync` **
O momento, em milésimos de segundos de epoch, no qual a última operação de `Sync` bem-sucedida foi iniciada. Se especificado, somente os itens que foram alterados após `lastSync` serão retornados. Este campo é opcional e deve ser preenchido somente depois de recuperar todas as páginas de uma operação inicial de `Sync`. Se omitido, os resultados da tabela *Base* serão retornados, caso contrário, os resultados da tabela *Delta* serão retornados.
**`basePartitionKey`**
A chave de partição da tabela *Base* usada ao realizar uma operação `Sync`. Esse campo permite que uma operação `Sync` seja executada quando a tabela utiliza uma chave de partição personalizada. Esse é um campo opcional.
**`deltaIndexName`**
O índice usado para a operação `Sync`. Esse índice é necessário para habilitar uma operação `Sync` em toda a tabela de armazenamento delta quando a tabela usa uma chave de partição personalizada. A operação `Sync` será executada no GSI (criado em `gsi_ds_pk` e `gsi_ds_sk`). Esse campo é opcional.
Os resultados retornados pela sincronização do DynamoDB são automaticamente convertidos nos tipos primitivos GraphQL e JSON e estão disponíveis no resultado do contexto (`context.result`).
Para obter mais informações sobre a conversão de tipo do DynamoDB, consulte [Sistema de tipo (mapeamento da resposta)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obter mais informações sobre JavaScript resolvedores, consulte a visão geral dos [JavaScript resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html).
Os resultados possuem a seguinte estrutura:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10,
startedAt = 1550000000000
}
```
Os campos são definidos da seguinte forma:
** `items` **
Uma lista que contém os itens retornados pela sincronização.
** `nextToken` **
Se houver mais resultados, `nextToken` contém um token de paginação que você pode usar em outra solicitação. AWS AppSync criptografa e ofusca o token de paginação retornado do DynamoDB. Isso impede que os dados da sua tabela sejam divulgados inadvertidamente para o chamador. Além disso, esses tokens de paginação não podem ser usados em diferentes funções ou resolvedores.
** `scannedCount` **
O número de itens recuperados pelo DynamoDB antes da aplicação de uma expressão de filtro (se houver).
** `startedAt` **
O momento, em milésimos de segundos de epoch, no qual a operação de sincronização foi iniciada e você pode armazenar localmente e usar em outra solicitação como seu argumento `lastSync`. Se um token de paginação foi incluído na solicitação, esse valor será o mesmo que o retornado pela solicitação para a primeira página de resultados.
## Exemplo
O exemplo a seguir é um manipulador de solicitação de função para uma consulta `syncPosts(nextToken: String, lastSync: AWSTimestamp)` GraphQL.
Neste exemplo, se `lastSync` for omitido, todas as entradas na tabela base serão retornadas. Se `lastSync` for fornecido, somente as entradas na tabela de sincronização delta que foram alteradas desde `lastSync` serão retornadas.
```
export function request(ctx) {
const { nextToken, lastSync } = ctx.args;
return { operation: 'Sync', limit: 100, nextToken, lastSync };
}
```
# BatchGetItem
O objeto de `BatchGetItem` solicitação permite que você peça à função do AWS AppSync DynamoDB que faça uma `BatchGetItem` solicitação ao DynamoDB para recuperar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o seguinte:
+ Os nomes da tabela da qual recuperar os itens
+ As chaves dos itens a serem recuperadas de cada tabela
Os limites `BatchGetItem` do DynamoDB se aplicam e **nenhuma expressão de condição** pode ser fornecida.
O objeto de solicitação `BatchGetItem` tem a seguinte estrutura:
```
type DynamoDBBatchGetItemRequest = {
operation: 'BatchGetItem';
tables: {
[tableName: string]: {
keys: { [key: string]: any }[];
consistentRead?: boolean;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
};
};
```
Os campos são definidos da seguinte forma:
## BatchGetItem campos
### BatchGetItem lista de campos
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `BatchGetItem` do DynamoDB, ela deve ser definida como `BatchGetItem`. Este valor é obrigatório.
** `tables` **
As tabelas do DynamoDB das quais recuperar os itens. O valor é um mapa no qual os nomes das tabelas são especificados como as chaves do mapa. Pelo menos uma tabela deve ser fornecida. Este valor `tables` é obrigatório.
** `keys` **
Lista de chaves do DynamoDB representando a chave primária dos itens a serem recuperados. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request).
** `consistentRead` **
Se deve usar uma leitura consistente ao executar uma *GetItem*operação. Esse valor é opcional e o padrão é *falso*.
**`projection`**
Uma projeção usada para especificar os atributos a serem retornados da operação do DynamoDB. Para obter mais informações sobre projeções, consulte [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Esse campo é opcional.
Informações importantes:
+ Se um item não tiver sido recuperado da tabela, um elemento *nulo* aparecerá no bloco de dados dessa tabela.
+ Os resultados de invocação são classificados por tabela, com base na ordem em que foram fornecidos dentro do objeto de solicitação.
+ Cada comando `Get` dentro de um `BatchGetItem` é atômico, no entanto, um lote pode ser parcialmente processado. Se um lote for parcialmente processado devido a um erro, as chaves não processadas serão retornadas como parte do resultado da chamada dentro do bloco *unprocessedKeys*.
+ O `BatchGetItem` é limitado a 100 chaves.
Veja a seguir um exemplo de manipulador de solicitação de função:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchGetItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
O resultado de invocação disponível em `ctx.result` é o seguinte:
```
{
"data": {
"authors": [null],
"posts": [
// Was retrieved
{
"authorId": "a1",
"postId": "p2",
"postTitle": "title",
"postDescription": "description",
}
]
},
"unprocessedKeys": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
O `ctx.error` contém detalhes sobre o erro. As chaves **data**, **unprocessedKeys** e todas as chaves de tabela fornecidas no resultado do objeto de solicitação de função estão presentes no resultado da invocação. Os itens que foram excluídos aparecem no bloco **data**. Itens que não foram processados são marcados como *nulos* no bloco de dados e colocados dentro do bloco **unprocessedKeys**.
# BatchDeleteItem
O objeto de `BatchDeleteItem` solicitação permite que você peça à função do AWS AppSync DynamoDB que faça uma `BatchWriteItem` solicitação ao DynamoDB para excluir vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o seguinte:
+ Os nomes da tabela da qual excluir os itens
+ As chaves dos itens a serem excluídas de cada tabela
Os limites `BatchWriteItem` do DynamoDB se aplicam e **nenhuma expressão de condição** pode ser fornecida.
O objeto de solicitação `BatchDeleteItem` tem a seguinte estrutura:
```
type DynamoDBBatchDeleteItemRequest = {
operation: 'BatchDeleteItem';
tables: {
[tableName: string]: { [key: string]: any }[];
};
};
```
Os campos são definidos da seguinte forma:
## BatchDeleteItem campos
### BatchDeleteItem lista de campos
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `BatchDeleteItem` do DynamoDB, ela deve ser definida como `BatchDeleteItem`. Este valor é obrigatório.
** `tables` **
As tabelas do DynamoDB das quais excluir os itens. Cada tabela é uma lista de chaves do DynamoDB representando a chave primária dos itens a serem excluídos. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Pelo menos uma tabela deve ser fornecida. O valor `tables` é obrigatório.
Informações importantes:
+ Ao contrário da operação `DeleteItem`, o item totalmente excluído não é retornado na resposta. Somente a chave passada é retornada.
+ Se um item não tiver sido excluído da tabela, um elemento *nulo* aparecerá no bloco de dados dessa tabela.
+ Os resultados de invocação são classificados por tabela, com base na ordem em que foram fornecidos dentro do objeto de solicitação.
+ Cada comando `Delete` dentro de um `BatchDeleteItem` é atômico. No entanto, um lote pode ser parcialmente processado. Se um lote for parcialmente processado devido a um erro, as chaves não processadas serão retornadas como parte do resultado da chamada dentro do bloco *unprocessedKeys*.
+ O `BatchDeleteItem` é limitado a 25 chaves.
+ Essa operação **não é** compatível quando usada com detecção de conflitos. Usar ambos ao mesmo tempo pode gerar um erro.
Veja a seguir um exemplo de manipulador de solicitação de função:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchDeleteItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
O resultado de invocação disponível em `ctx.result` é o seguinte:
```
{
"data": {
"authors": [null],
"posts": [
// Was deleted
{
"authorId": "a1",
"postId": "p2"
}
]
},
"unprocessedKeys": {
"authors": [
// This key was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
O `ctx.error` contém detalhes sobre o erro. As chaves **data**, **unprocessedKeys** e todas as chaves de tabela fornecidas no objeto de solicitação de função estão presentes no resultado da invocação. Os itens que foram excluídos estão presentes no bloco **data**. Itens que não foram processados são marcados como *nulos* no bloco de dados e colocados dentro do bloco **unprocessedKeys**.
# BatchPutItem
O objeto de `BatchPutItem` solicitação permite que você peça à função do AWS AppSync DynamoDB que faça uma `BatchWriteItem` solicitação ao DynamoDB para colocar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o seguinte:
+ Os nomes da tabela na qual inserir os itens
+ Os itens completos a serem inseridos em cada tabela
Os limites `BatchWriteItem` do DynamoDB se aplicam e **nenhuma expressão de condição** pode ser fornecida.
O objeto de solicitação `BatchPutItem` tem a seguinte estrutura:
```
type DynamoDBBatchPutItemRequest = {
operation: 'BatchPutItem';
tables: {
[tableName: string]: { [key: string]: any}[];
};
};
```
Os campos são definidos da seguinte forma:
## BatchPutItem campos
### BatchPutItem lista de campos
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `BatchPutItem` do DynamoDB, ela deve ser definida como `BatchPutItem`. Este valor é obrigatório.
** `tables` **
As tabelas do DynamoDB nas quais inserir os itens. Cada entrada da tabela representa uma lista de itens do DynamoDB a serem inseridos nesta tabela específica. Pelo menos uma tabela deve ser fornecida. Este valor é obrigatório.
Informações importantes:
+ Os itens totalmente inseridos são retornados na resposta, se bem-sucedidos.
+ Se um item não tiver sido inserido na tabela, um elemento *nulo* será exibido no bloco de dados dessa tabela.
+ Os itens inseridos são classificados por tabela, com base na ordem em que foram fornecidos dentro do objeto de solicitação.
+ Cada comando `Put` dentro de um `BatchPutItem` é atômico, no entanto, um lote pode ser parcialmente processado. Se um lote for parcialmente processado devido a um erro, as chaves não processadas serão retornadas como parte do resultado da chamada dentro do bloco *unprocessedKeys*.
+ O `BatchPutItem` é limitado a 25 itens.
+ Essa operação **não é** compatível quando usada com detecção de conflitos. Usar ambos ao mesmo tempo pode gerar um erro.
Veja a seguir um exemplo de manipulador de solicitação de função:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, name, title } = ctx.args;
return {
operation: 'BatchPutItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId, name })],
posts: [util.dynamodb.toMapValues({ authorId, postId, title })],
},
};
}
```
O resultado de invocação disponível em `ctx.result` é o seguinte:
```
{
"data": {
"authors": [
null
],
"posts": [
// Was inserted
{
"authorId": "a1",
"postId": "p2",
"title": "title"
}
]
},
"unprocessedItems": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1",
"name": "a1_name"
}
],
"posts": []
}
}
```
O `ctx.error` contém detalhes sobre o erro. As chaves **data**, **unprocessedItems** e todas as chaves de tabela fornecidas no objeto de solicitação estão presentes no resultado da invocação. Os itens que foram inseridos estão no bloco **data**. Itens que não foram processados são marcados como *nulos* no bloco de dados e colocados dentro do bloco **unprocessedItems**.
# TransactGetItems
O objeto de `TransactGetItems` solicitação permite que você peça à função do AWS AppSync DynamoDB que faça uma `TransactGetItems` solicitação ao DynamoDB para recuperar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o seguinte:
+ O nome da tabela de cada item de solicitação de onde recuperar o item
+ A chave de cada item de solicitação a ser recuperado de cada tabela
Os limites `TransactGetItems` do DynamoDB se aplicam e **nenhuma expressão de condição** pode ser fornecida.
O objeto de solicitação `TransactGetItems` tem a seguinte estrutura:
```
type DynamoDBTransactGetItemsRequest = {
operation: 'TransactGetItems';
transactItems: { table: string; key: { [key: string]: any }; projection?: { expression: string; expressionNames?: { [key: string]: string }; }[];
};
};
```
Os campos são definidos da seguinte forma:
## TransactGetItems campos
### TransactGetItems lista de campos
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `TransactGetItems` do DynamoDB, ela deve ser definida como `TransactGetItems`. Este valor é obrigatório.
** `transactItems` **
Os itens de solicitação a serem incluídos. O valor é uma matriz de itens de solicitação. Pelo menos um item de solicitação deve ser fornecido. Este valor `transactItems` é obrigatório.
** `table` **
A tabela do DynamoDB da qual recuperar o item. O valor é uma string do nome da tabela. Este valor `table` é obrigatório.
** `key` **
A chave do DynamoDB representando a chave primária do item a ser recuperado. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request).
**`projection`**
Uma projeção usada para especificar os atributos a serem retornados da operação do DynamoDB. Para obter mais informações sobre projeções, consulte [Projeções](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Esse campo é opcional.
Informações importantes:
+ Se uma transação for bem-sucedida, a ordem dos itens recuperados no bloco `items` será a mesma que a ordem dos itens solicitados.
+ As transações são realizadas de all-or-nothing alguma forma. Se algum item de solicitação causar um erro, não será executada a transação inteira e os detalhes do erro serão retornados.
+ Um item de solicitação que não pode ser recuperado não é um erro. Em vez disso, um elemento *nulo* aparece no bloco de *itens* na posição correspondente.
+ Se o erro de uma transação for *TransactionCanceledException*, o `cancellationReasons` bloco será preenchido. A ordem dos motivos de cancelamento no bloco `cancellationReasons` será a mesma que a ordem de itens solicitados.
+ `TransactGetItems` está limitado a 100 itens de solicitação.
Veja a seguir um exemplo de manipulador de solicitação de função:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'TransactGetItems',
transactItems: [
{
table: 'posts',
key: util.dynamodb.toMapValues({ postId }),
},
{
table: 'authors',
key: util.dynamodb.toMapValues({ authorId }),
},
],
};
}
```
Se a transação for bem-sucedida e somente o primeiro item solicitado for recuperado, o resultado de invocação disponível em `ctx.result` será o seguinte:
```
{
"items": [
{
// Attributes of the first requested item
"post_id": "p1",
"post_title": "title",
"post_description": "description"
},
// Could not retrieve the second requested item
null,
],
"cancellationReasons": null
}
```
Se a transação falhar devido à *TransactionCanceledException*causa do primeiro item da solicitação, o resultado da invocação `ctx.result` disponível em será o seguinte:
```
{
"items": null,
"cancellationReasons": [
{
"type":"Sample error type",
"message":"Sample error message"
},
{
"type":"None",
"message":"None"
}
]
}
```
O `ctx.error` contém detalhes sobre o erro. A presença dos **itens** de chaves e **cancelationReasons** está garantida em `ctx.result`.
# TransactWriteItems
O objeto de `TransactWriteItems` solicitação permite que você peça à função do AWS AppSync DynamoDB que faça uma `TransactWriteItems` solicitação ao DynamoDB para gravar vários itens, potencialmente em várias tabelas. Para esse objeto de solicitação, você deve especificar o seguinte:
+ O nome da tabela de destino de cada item de solicitação
+ A operação de cada item de solicitação a ser executado. Há quatro tipos de operações que são compatíveis: *PutItem*, *UpdateItem*, *DeleteItem*, e *ConditionCheck*
+ A chave de cada item de solicitação a ser gravado
Os limites `TransactWriteItems` do DynamoDB são aplicáveis.
O objeto de solicitação `TransactWriteItems` tem a seguinte estrutura:
```
type DynamoDBTransactWriteItemsRequest = {
operation: 'TransactWriteItems';
transactItems: TransactItem[];
};
type TransactItem =
| TransactWritePutItem
| TransactWriteUpdateItem
| TransactWriteDeleteItem
| TransactWriteConditionCheckItem;
type TransactWritePutItem = {
table: string;
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: string};
condition?: TransactConditionCheckExpression;
};
type TransactWriteUpdateItem = {
table: string;
operation: 'UpdateItem';
key: { [key: string]: any };
update: DynamoDBExpression;
condition?: TransactConditionCheckExpression;
};
type TransactWriteDeleteItem = {
table: string;
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactWriteConditionCheckItem = {
table: string;
operation: 'ConditionCheck';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
returnValuesOnConditionCheckFailure: boolean;
};
```
## TransactWriteItems campos
### TransactWriteItems lista de campos
**Os campos são definidos da seguinte forma: **
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `TransactWriteItems` do DynamoDB, ela deve ser definida como `TransactWriteItems`. Este valor é obrigatório.
** `transactItems` **
Os itens de solicitação a serem incluídos. O valor é uma matriz de itens de solicitação. Pelo menos um item de solicitação deve ser fornecido. Este valor `transactItems` é obrigatório.
Em `PutItem`, os campos são definidos da seguinte forma:
** `table` **
A tabela de destino do DynamoDB. O valor é uma string do nome da tabela. Este valor `table` é obrigatório.
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `PutItem` do DynamoDB, ela deve ser definida como `PutItem`. Este valor é obrigatório.
** `key` **
A chave do DynamoDB representando a chave primária do item a ser inserida. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
** `attributeValues` **
O restante dos atributos do item a ser colocado no DynamoDB. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Esse campo é opcional.
** `condition` **
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, uma solicitação `PutItem` substitui qualquer entrada existente para esse item. Você pode especificar se deseja recuperar o item existente quando a verificação de condição falhar. Para obter mais informações sobre as condições transacionais, consulte [Expressões de condição da transação](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor é opcional.
Em `UpdateItem`, os campos são definidos da seguinte forma:
** `table` **
A tabela do DynamoDB a ser atualizada. O valor é uma string do nome da tabela. Este valor `table` é obrigatório.
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `UpdateItem` do DynamoDB, ela deve ser definida como `UpdateItem`. Este valor é obrigatório.
** `key` **
A chave do DynamoDB representando a chave primária do item a ser atualizada. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
** `update` **
A seção `update` permite especificar uma expressão de atualização que descreve como atualizar o item no DynamoDB. Para obter mais informações sobre como escrever expressões de atualização, consulte a documentação do [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta seção é obrigatória.
** `condition` **
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, a solicitação `UpdateItem` atualizará as entradas existentes independentemente do estado atual. Você pode especificar se deseja recuperar o item existente quando a verificação de condição falhar. Para obter mais informações sobre as condições transacionais, consulte [Expressões de condição da transação](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor é opcional.
Em `DeleteItem`, os campos são definidos da seguinte forma:
** `table` **
A tabela do DynamoDB na qual excluir o item. O valor é uma string do nome da tabela. Este valor `table` é obrigatório.
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `DeleteItem` do DynamoDB, ela deve ser definida como `DeleteItem`. Este valor é obrigatório.
** `key` **
A chave do DynamoDB representando a chave primária do item a ser excluída. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
** `condition` **
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Se nenhuma condição for especificada, a solicitação `DeleteItem` excluirá um item independentemente do estado atual. Você pode especificar se deseja recuperar o item existente quando a verificação de condição falhar. Para obter mais informações sobre as condições transacionais, consulte [Expressões de condição da transação](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor é opcional.
Em `ConditionCheck`, os campos são definidos da seguinte forma:
** `table` **
A tabela do DynamoDB na qual verificar a condição. O valor é uma string do nome da tabela. Este valor `table` é obrigatório.
** `operation` **
A operação do DynamoDB para execução. Para executar a operação `ConditionCheck` do DynamoDB, ela deve ser definida como `ConditionCheck`. Este valor é obrigatório.
** `key` **
A chave do DynamoDB representando a chave primária do item para verificar a condição. Os itens do DynamoDB podem ter uma única chave de hash ou uma chave de hash e uma chave de classificação, dependendo da estrutura da tabela. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor é obrigatório.
** `condition` **
Uma condição para determinar se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB. Você pode especificar se deseja recuperar o item existente quando a verificação de condição falhar. Para obter mais informações sobre as condições transacionais, consulte [Expressões de condição da transação](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor é obrigatório.
Informações importantes:
+ Somente chaves de itens de solicitação são retornadas na resposta, se bem-sucedidas. A ordem das chaves será a mesma que a ordem dos itens solicitados.
+ As transações são realizadas de all-or-nothing alguma forma. Se algum item de solicitação causar um erro, não será executada a transação inteira e os detalhes do erro serão retornados.
+ Dois itens de solicitação não podem segmentar o mesmo item. Caso contrário, eles causarão *TransactionCanceledException*erros.
+ Se o erro de uma transação for *TransactionCanceledException*, o `cancellationReasons` bloco será preenchido. Se a verificação de condição de um item de solicitação falhar **e** você não especificar `returnValuesOnConditionCheckFailure` como `false`, o item existente na tabela será recuperado e armazenado em `item` na posição correspondente do bloco `cancellationReasons`.
+ `TransactWriteItems` está limitado a 100 itens de solicitação.
+ Essa operação **não é** compatível quando usada com detecção de conflitos. Usar ambos ao mesmo tempo pode gerar um erro.
Veja a seguir um exemplo de manipulador de solicitação de função:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, title, description, oldTitle, authorName } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'PutItem',
key: util.dynamodb.toMapValues({ postId }),
attributeValues: util.dynamodb.toMapValues({ title, description }),
condition: util.transform.toDynamoDBConditionExpression({
title: { eq: oldTitle },
}),
},
{
table: 'authors',
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ authorId }),
update: {
expression: 'SET authorName = :name',
expressionValues: util.dynamodb.toMapValues({ ':name': authorName }),
},
},
],
};
}
```
Se a transação for bem-sucedida, o resultado de invocação disponível em `ctx.result` será o seguinte:
```
{
"keys": [
// Key of the PutItem request
{
"post_id": "p1",
},
// Key of the UpdateItem request
{
"author_id": "a1"
}
],
"cancellationReasons": null
}
```
Se a transação falhar devido a falha de verificação de condição da solicitação `PutItem`, o resultado de invocação disponível em `ctx.result` será o seguinte:
```
{
"keys": null,
"cancellationReasons": [
{
"item": {
"post_id": "p1",
"post_title": "Actual old title",
"post_description": "Old description"
},
"type": "ConditionCheckFailed",
"message": "The condition check failed."
},
{
"type": "None",
"message": "None"
}
]
}
```
O `ctx.error` contém detalhes sobre o erro. A presença de **chaves** e **cancelationReasons** está garantida em `ctx.result`.
# Sistema de tipo (mapeamento da solicitação)
Ao usar a função do AWS AppSync DynamoDB para chamar suas tabelas do DynamoDB AWS AppSync , precisa saber o tipo de cada valor a ser usado nessa chamada. Isso ocorre porque o DynamoDB suporta mais tipos primitivos do que GraphQL ou JSON (como conjuntos e dados binários). AWS AppSync precisa de algumas dicas ao traduzir entre o GraphQL e o DynamoDB, caso contrário, seria necessário fazer algumas suposições sobre como os dados são estruturados em sua tabela.
Para obter mais informações sobre os tipos de dados do DynamoDB, consulte os [Descritores de tipos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors) do DynamoDB e a documentação dos [Tipos de dados](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes).
Um valor do DynamoDB é representado por um objeto JSON que contém um único par de chave-valor. A chave especifica o tipo do DynamoDB e o valor que especifica o valor em si. No exemplo a seguir, a chave `S` indica que o valor é uma string e o valor `identifier` é o próprio valor da string.
```
{ "S" : "identifier" }
```
Observe que o objeto JSON não pode ter mais de um par de chave-valor. Se mais de um par de chave/valor for especificado, o objeto da solicitação não será analisado.
Um valor do DynamoDB é usado em qualquer lugar no objeto da solicitação onde é necessário especificar um valor. Alguns lugares onde é necessário fazer isso incluem: as seções `key` e `attributeValue`, e a seção `expressionValues` das seções de expressões. No exemplo a seguir, o valor da string `identifier` do DynamoDB está sendo atribuído ao campo `id` em uma seção `key` (talvez em um objeto da solicitação `GetItem`).
```
"key" : {
"id" : { "S" : "identifier" }
}
```
**Tipos compatíveis**
AWS AppSync é compatível com os seguintes tipos de escalar, documento e conjunto do DynamoDB:
**Tipo string `S` **
O valor de uma única string. O valor de uma string do DynamoDB é indicado por:
```
{ "S" : "some string" }
```
Um exemplo de uso é:
```
"key" : {
"id" : { "S" : "some string" }
}
```
**Tipo conjunto de strings `SS` **
Um conjunto de valores de strings. O valor de conjunto de strings do DynamoDB é indicado por:
```
{ "SS" : [ "first value", "second value", ... ] }
```
Um exemplo de uso é:
```
"attributeValues" : {
"phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```
**Tipo número `N` **
Um único valor numérico. O valor de um número do DynamoDB é indicado por:
```
{ "N" : 1234 }
```
Um exemplo de uso é:
```
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
}
```
**Tipo conjunto de números `NS` **
Um conjunto de valores de números. O valor de conjunto de números do DynamoDB é indicado por:
```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Um exemplo de uso é:
```
"attributeValues" : {
"sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```
**Tipo binário `B` **
Um valor binário. Um valor binário do DynamoDB é indicado por:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Observe que o valor é, na verdade, uma string, em que a string é a representação codificada em base64 dos dados binários. AWS AppSync decodifica essa string de volta em seu valor binário antes de enviá-la para o DynamoDB. AWS AppSync usa o esquema de decodificação base64 conforme definido pela RFC 2045: qualquer caractere que não esteja no alfabeto base64 é ignorado.
Um exemplo de uso é:
```
"attributeValues" : {
"binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```
**Tipo conjunto de binários `BS` **
Um conjunto de valores binários. Um valor de conjunto de binários do DynamoDB é indicado por:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Observe que o valor é, na verdade, uma string, em que a string é a representação codificada em base64 dos dados binários. AWS AppSync decodifica essa string de volta em seu valor binário antes de enviá-la para o DynamoDB. AWS AppSync usa o esquema de decodificação base64 conforme definido pela RFC 2045: qualquer caractere que não esteja no alfabeto base64 é ignorado.
Um exemplo de uso é:
```
"attributeValues" : {
"binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```
**Tipo booliano `BOOL` **
Um valor booleano. Um valor Booleano do DynamoDB é indicado por:
```
{ "BOOL" : true }
```
Observe que apenas `true` e `false` são valores válidos.
Um exemplo de uso é:
```
"attributeValues" : {
"orderComplete" : { "BOOL" : false }
}
```
**Tipo lista `L` **
Uma lista de qualquer outro valor do DynamoDB compatível. O valor de lista do DynamoDB é indicado por:
```
{ "L" : [ ... ] }
```
Observe que o valor é um valor composto, onde a lista pode conter zero ou mais de qualquer valor do DynamoDB compatível (incluindo outras listas). A lista também pode conter uma mistura de diferentes tipos.
Um exemplo de uso é:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
**Tipo mapa `M` **
Representando uma coleção não ordenada de pares de chave/valor de outros valores do DynamoDB compatíveis. O valor de mapa do DynamoDB é indicado por:
```
{ "M" : { ... } }
```
Observe que um mapa pode conter zero ou mais pares de chave/valor. A chave deve ser uma string, e o valor pode ser qualquer valor do DynamoDB compatível (incluindo outros mapas). O mapa também pode conter uma mistura de diferentes tipos.
Um exemplo de uso é:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
**Tipo nulo `NULL` **
Um valor nulo. O valor nulo do DynamoDB é indicado por:
```
{ "NULL" : null }
```
Um exemplo de uso é:
```
"attributeValues" : {
"phoneNumbers" : { "NULL" : null }
}
```
para obter mais informações sobre cada tipo, consulte a [Documentação do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).
# Sistema de tipo (mapeamento da resposta)
Ao receber uma resposta do DynamoDB AWS AppSync , a converte automaticamente em tipos primitivos GraphQL e JSON. Cada atributo no DynamoDB é decodificado e retornado no contexto do manipulador da resposta.
Por exemplo, se o DynamoDB retorna o seguinte:
```
{
"id" : { "S" : "1234" },
"name" : { "S" : "Nadia" },
"age" : { "N" : 25 }
}
```
Quando o resultado é retornado do seu resolvedor de pipeline, ele é AWS AppSync convertido em tipos GraphQL e JSON como:
```
{
"id" : "1234",
"name" : "Nadia",
"age" : 25
}
```
Esta seção explica como AWS AppSync converte os seguintes tipos de escalar, documento e conjunto do DynamoDB:
**Tipo string `S` **
O valor de uma única string. Um valor de string do DynamoDB é retornado como uma string.
Por exemplo, se o DynamoDB retornou o seguinte valor de string do DynamoDB:
```
{ "S" : "some string" }
```
AWS AppSync o converte em uma string:
```
"some string"
```
**Tipo conjunto de strings `SS` **
Um conjunto de valores de strings. Um valor de conjunto de strings do DynamoDB é retornado simplesmente como uma lista de strings.
Por exemplo, se o DynamoDB retornou o seguinte valor de conjunto de strings do DynamoDB:
```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync o converte em uma lista de strings:
```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```
**Tipo número `N` **
Um único valor numérico. Um valor de número do DynamoDB é retornado como um número.
Por exemplo, se o DynamoDB retornou o seguinte valor de número do DynamoDB:
```
{ "N" : 1234 }
```
AWS AppSync o converte em um número:
```
1234
```
**Tipo conjunto de números `NS` **
Um conjunto de valores de números. Um valor de conjunto de números do DynamoDB é retornado simplesmente como uma lista de números.
Por exemplo, se o DynamoDB retornou o seguinte valor de conjunto de números do DynamoDB:
```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync o converte em uma lista de números:
```
[ 67.8, 12.2, 70 ]
```
**Tipo binário `B` **
Um valor binário. Um valor binário do DynamoDB é retornado como uma string que contém a representação em base64 desse valor.
Por exemplo, se o DynamoDB retornou o seguinte valor binário do DynamoDB:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync o converte em uma string contendo a representação base64 do valor:
```
"SGVsbG8sIFdvcmxkIQo="
```
Observe que os dados binários estão codificados no esquema de codificação base64 conforme especificado em [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).
**Tipo conjunto de binários `BS` **
Um conjunto de valores binários. Um valor de conjunto de binários do DynamoDB é retornado como uma lista de strings que contém a representação em base64 dos valores.
Por exemplo, se o DynamoDB retornou o seguinte valor de conjuntos de binários do DynamoDB:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync o converte em uma lista de strings contendo a representação base64 dos valores:
```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
Observe que os dados binários estão codificados no esquema de codificação base64 conforme especificado em [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).
**Tipo booliano `BOOL` **
Um valor booleano. Um valor Booleano do DynamoDB é retornado como um Booleano.
Por exemplo, se o DynamoDB retornou o seguinte valor Booleano do DynamoDB:
```
{ "BOOL" : true }
```
AWS AppSync o converte em um booleano:
```
true
```
**Tipo lista `L` **
Uma lista de qualquer outro valor do DynamoDB compatível. Um valor de lista do DynamoDB é retornado como uma lista de valores, onde cada valor interno também é convertido.
Por exemplo, se o DynamoDB retornou o seguinte valor de lista do DynamoDB:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
AWS AppSync o converte em uma lista de valores convertidos:
```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```
**Tipo mapa `M` **
Uma key/value coleção de qualquer outro valor compatível do DynamoDB. Um valor do DynamoDB Map é retornado como um objeto JSON, onde key/value cada um também é convertido.
Por exemplo, se o DynamoDB retornou o seguinte valor de mapa do DynamoDB:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
AWS AppSync o converte em um objeto JSON:
```
{
"someString" : "A string value",
"someNumber" : 1,
"stringSet" : [ "Another string value", "Even more string values!" ]
}
```
**Tipo nulo `NULL` **
Um valor nulo.
Por exemplo, se o DynamoDB retornou o seguinte valor nulo do DynamoDB:
```
{ "NULL" : null }
```
AWS AppSync o converte em um nulo:
```
null
```
# Filtros
Ao consultar objetos no DynamoDB usando as operações `Query` e `Scan`, opcionalmente, você pode especificar um `filter` que avalia os resultados e retorna apenas os valores desejados.
A propriedade de filtro de uma solicitação `Scan` ou `Query` tem a seguinte estrutura:
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
};
```
Os campos são definidos da seguinte forma:
** `expression` **
A expressão da consulta. Para obter mais informações sobre como escrever expressões de filtro, consulte a documentação do [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html) [e ScanFilter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html) do QueryFilter DynamoDB. Esse campo deve ser especificado.
** `expressionNames` **
As substituições para espaços reservados de *nome* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de nome usado na `expression`. O valor deve ser uma string que corresponde ao nome de atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados em `expression`.
** `expressionValues` **
As substituições para espaços reservados de *valor* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na `expression` e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Isso deve ser especificado. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados em `expression`.
## Exemplo
Veja a seguir uma seção de filtro para uma solicitação, onde as entradas recuperadas do DynamoDB só são retornadas se o título começa com o argumento `title`.
Aqui, usamos o `util.transform.toDynamoDBFilterExpression` para criar automaticamente um filtro a partir de um objeto:
```
const filter = util.transform.toDynamoDBFilterExpression({
title: { beginsWith: 'far away' },
});
const request = {};
request.filter = JSON.parse(filter);
```
Isso gera o seguinte filtro:
```
{
"filter": {
"expression": "(begins_with(#title,:title_beginsWith))",
"expressionNames": { "#title": "title" },
"expressionValues": {
":title_beginsWith": { "S": "far away" }
}
}
}
```
# Expressões de condição
Quando objetos sofrem mutação no DynamoDB usando as operações `PutItem`, `UpdateItem` e `DeleteItem` do DynamoDB, opcionalmente, é possível especificar uma expressão de condição que controla se a solicitação deve ser bem-sucedida ou não, com base no estado do objeto que já está no DynamoDB antes que a operação seja realizada.
A função AWS AppSync DynamoDB permite que uma expressão de condição seja especificada `PutItem` em`UpdateItem`,, `DeleteItem` e solicite objetos, além de uma estratégia a ser seguida se a condição falhar e o objeto não for atualizado.
## Exemplo 1
O objeto de solicitação `PutItem` a seguir não tem uma expressão de condição. Como resultado, ele coloca um item no DynamoDB mesmo se um item com a mesma chave já existir, sobrescrevendo o item existente.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Exemplo 2
O seguinte objeto `PutItem` possui uma expressão de condição que permite que a operação seja bem-sucedida somente se um item com a mesma chave *não existir* no DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
condition: { expression: "attribute_not_exists(id)" }
};
}
```
Por padrão, se a verificação da condição falhar, a função AWS AppSync DynamoDB fornecerá um erro para a mutação.
No entanto, a função AWS AppSync DynamoDB oferece alguns recursos adicionais para ajudar os desenvolvedores a lidar com alguns casos extremos comuns:
+ Se AWS AppSync as funções do DynamoDB conseguirem determinar que o valor atual no DynamoDB corresponde ao resultado desejado, ela tratará a operação como se tivesse sido bem-sucedida de qualquer maneira.
+ Em vez de retornar um erro, você pode configurar a função para invocar uma função Lambda personalizada para decidir como a função do AWS AppSync DynamoDB deve lidar com a falha.
Isso é descrito com mais detalhes na seção [Tratamento de uma falha de verificação da condição](#condition-check).
[Para obter mais informações sobre as expressões de condições do DynamoDB, consulte a documentação do DynamoDB. ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)
## Especificação de uma condição
Os objetos da solicitação `PutItem`, `UpdateItem` e `DeleteItem` permitem que uma seção `condition` opcional seja especificada. Se omitida, nenhuma verificação de condição é feita. Se especificada, a condição deve ser verdadeira para que a operação seja bem-sucedida.
A seção `condition` tem a seguinte estrutura:
```
type ConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
equalsIgnore?: string[];
consistentRead?: boolean;
conditionalCheckFailedHandler?: {
strategy: 'Custom' | 'Reject';
lambdaArn?: string;
};
};
```
Os campos a seguir especificam a condição:
** `expression` **
A própria expressão de atualização. Para obter mais informações sobre como escrever expressões condicionais, consulte a documentação do [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Esse campo deve ser especificado.
** `expressionNames` **
As substituições para espaços reservados de nome do atributo da expressão, na forma de pares de chave/valor. A chave corresponde a um espaço reservado de nome usado na *expressão* e o valor deve ser uma string que corresponde ao nome do atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados na *expressão*.
** `expressionValues` **
As substituições para espaços reservados de valor do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na expressão e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Isso deve ser especificado. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados na expressão.
Os campos restantes informam à função do AWS AppSync DynamoDB como lidar com uma falha na verificação de condição:
** `equalsIgnore` **
Quando uma verificação de condição falha ao usar a `PutItem` operação, a função do AWS AppSync DynamoDB compara o item atualmente no DynamoDB com o item que ela tentou gravar. Se forem os mesmos, ele tratará a operação como bem-sucedida. Você pode usar o `equalsIgnore` campo para especificar uma lista de atributos que AWS AppSync devem ser ignorados ao realizar essa comparação. Por exemplo, se a única diferença era um atributo `version`, ele trata a operação como bem-sucedida. Esse campo é opcional.
** `consistentRead` **
Quando uma verificação de condição falha, AWS AppSync obtém o valor atual do item do DynamoDB usando uma leitura altamente consistente. Você pode usar esse campo para fazer com que a função do AWS AppSync DynamoDB use uma leitura eventualmente consistente em vez disso. Esse campo é opcional e usa como padrão `true`.
** `conditionalCheckFailedHandler` **
Esta seção permite especificar como a função do AWS AppSync DynamoDB trata uma falha na verificação de condição depois de comparar o valor atual no DynamoDB com o resultado esperado. Esta seção é opcional. Se omitida, o padrão será uma estratégia de `Reject`.
** `strategy` **
A estratégia que a função do AWS AppSync DynamoDB adota depois de comparar o valor atual no DynamoDB com o resultado esperado. Esse campo é obrigatório e tem os valores possíveis a seguir:
** `Reject` **
A mutação falha, e um erro é adicionado à resposta do GraphQL.
** `Custom` **
A função AWS AppSync DynamoDB invoca uma função Lambda personalizada para decidir como lidar com a falha na verificação da condição. Quando a `strategy` estiver definida como `Custom`, o campo `lambdaArn` deve conter o ARN da função do Lambda a ser invocada.
** `lambdaArn` **
O ARN da função Lambda a ser invocada determina como a função do DynamoDB deve lidar com a falha na verificação da AWS AppSync condição. Esse campo deve ser especificado somente quando `strategy` for definida como `Custom`. Para obter mais informações sobre como usar esse atributo, consulte [Tratamento de uma falha de verificação da condição](#condition-check).
## Tratamento de uma falha de verificação da condição
Quando uma verificação de condição falha, a AWS AppSync função do DynamoDB pode transmitir o erro da mutação e o valor atual do objeto usando o utilitário. `util.appendError` No entanto, a função AWS AppSync DynamoDB oferece alguns recursos adicionais para ajudar os desenvolvedores a lidar com alguns casos extremos comuns:
+ Se AWS AppSync as funções do DynamoDB conseguirem determinar que o valor atual no DynamoDB corresponde ao resultado desejado, ela tratará a operação como se tivesse sido bem-sucedida de qualquer maneira.
+ Em vez de retornar um erro, você pode configurar a função para invocar uma função Lambda personalizada para decidir como a função do AWS AppSync DynamoDB deve lidar com a falha.
O fluxograma para esse processo é:
![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/pt_br/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)
### Verificação do resultado desejado
Quando a verificação da condição falha, a função do AWS AppSync DynamoDB executa uma solicitação do `GetItem` DynamoDB para obter o valor atual do item do DynamoDB. Por padrão, ele usa uma leitura fortemente consistente, mas isso pode ser configurado usando o campo `consistentRead` no bloco `condition` e compará-lo com o resultado esperado:
+ Para a `PutItem` operação, a função AWS AppSync DynamoDB compara o valor atual com o que ela tentou gravar, excluindo quaisquer atributos listados na comparação. `equalsIgnore` Se os itens forem os mesmos, ele tratará a operação como bem-sucedida e retornará o item recuperado do DynamoDB. Caso contrário, ele seguirá a estratégia configurada.
Por exemplo, se o objeto da solicitação `PutItem` se parecer com o seguinte:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, name, version} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues({ name, version: version+1 }),
condition: {
expression: "version = :expectedVersion",
expressionValues: util.dynamodb.toMapValues({':expectedVersion': version}),
equalsIgnore: ['version']
}
};
}
```
E o item que está atualmente no DynamoDB se parecer com o seguinte:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
A AWS AppSync função do DynamoDB compararia o item que tentou gravar com o valor atual, verificaria que a única diferença era `version` o campo, mas, como está configurada para ignorar `version` o campo, ela considera a operação bem-sucedida e retorna o item que foi recuperado do DynamoDB.
+ Para a `DeleteItem` operação, a função do AWS AppSync DynamoDB verifica se um item foi retornado do DynamoDB. Se nenhum item foi retornado, ele tratará a operação como bem-sucedida. Caso contrário, ele seguirá a estratégia configurada.
+ Para a `UpdateItem` operação, a função do AWS AppSync DynamoDB não tem informações suficientes para determinar se o item atualmente no DynamoDB corresponde ao resultado esperado e, portanto, segue a estratégia configurada.
Se o estado atual do objeto no DynamoDB for diferente do resultado esperado, a função do AWS AppSync DynamoDB segue a estratégia configurada para rejeitar a mutação ou invocar uma função Lambda para determinar o que fazer a seguir.
### Seguir a estratégia "Rejeitar"
Ao seguir a `Reject` estratégia, a função AWS AppSync DynamoDB retorna um erro para a mutação.
Por exemplo, considere a solicitação de mutação a seguir:
```
mutation {
updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
Name
theVersion
}
}
```
Se o item retornado do DynamoDB for semelhante ao seguinte:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
E o manipulador de resposta da função tem a seguinte aparência:
```
import { util } from '@aws-appsync/utils';
export function response(ctx) {
const { version, ...values } = ctx.result;
const result = { ...values, theVersion: version };
if (ctx.error) {
if (error) {
return util.appendError(error.message, error.type, result, null);
}
}
return result
}
```
A resposta do GraphQL é semelhante à seguinte:
```
{
"data": null,
"errors": [
{
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
"errorType": "DynamoDB:ConditionalCheckFailedException",
...
}
]
}
```
Além disso, se qualquer campo no objeto retornado for preenchido por outros resolvedores e a mutação foi bem-sucedida, eles não serão resolvidos quando o objeto for retornado na seção `error`.
### Seguir a estratégia "Personalizada"
Ao seguir a `Custom` estratégia, a função do AWS AppSync DynamoDB invoca uma função Lambda para decidir o que fazer em seguida. A Função Lambda escolhe um destas opções a seguir:
+ `reject` a mutação. Isso faz com que a AWS AppSync função do DynamoDB se comporte como se a estratégia configurada `Reject` fosse, retornando um erro para a mutação e o valor atual do objeto no DynamoDB, conforme descrito na seção anterior.
+ `discard` a mutação. Isso faz com que a função do AWS AppSync DynamoDB ignore silenciosamente a falha na verificação da condição e retorne o valor no DynamoDB.
+ `retry` a mutação. Isso faz com que a AWS AppSync função do DynamoDB repita a mutação com um novo objeto de solicitação.
**A solicitação de invocação do Lambda**
A função AWS AppSync DynamoDB invoca a função Lambda especificada no. `lambdaArn` Ele usa o mesmo `service-role-arn` configurado na fonte de dados. A carga da invocação tem a seguinte estrutura:
```
{
"arguments": { ... },
"requestMapping": {... },
"currentValue": { ... },
"resolver": { ... },
"identity": { ... }
}
```
Os campos são definidos da seguinte forma:
** `arguments` **
Os argumentos da mutação do GraphQL. Isso é o mesmo que os argumentos disponíveis para o objeto da solicitação em `context.arguments`.
** `requestMapping` **
O objeto de solicitação para essa operação.
** `currentValue` **
O valor atual do objeto no DynamoDB.
** `resolver` **
Informações sobre o AWS AppSync resolvedor ou a função.
** `identity` **
Informações sobre o chamador. Isso é o mesmo que as informações de identidade disponíveis para o objeto da solicitação em `context.identity`.
Um exemplo completo da carga:
```
{
"arguments": {
"id": "1",
"name": "Steve",
"expectedVersion": 1
},
"requestMapping": {
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"attributeValues" : {
"name" : { "S" : "Steve" },
"version" : { "N" : 2 }
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
},
"equalsIgnore": [ "version" ]
}
},
"currentValue": {
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
},
"resolver": {
"tableName": "People",
"awsRegion": "us-west-2",
"parentType": "Mutation",
"field": "updatePerson",
"outputType": "Person"
},
"identity": {
"accountId": "123456789012",
"sourceIp": "x.x.x.x",
"user": "AIDAAAAAAAAAAAAAAAAAA",
"userArn": "arn:aws:iam::123456789012:user/appsync"
}
}
```
**A resposta de invocação do Lambda**
A função Lambda pode inspecionar a carga de invocação e aplicar qualquer lógica de negócios para decidir como a função do DynamoDB deve lidar com a falha AWS AppSync . Existem três opções para tratamento da falha de verificação da condição:
+ `reject` a mutação. A carga da resposta para essa opção deve ter a seguinte estrutura:
```
{
"action": "reject"
}
```
Isso faz com que a AWS AppSync função do DynamoDB se comporte como se a estratégia configurada `Reject` fosse, retornando um erro para a mutação e o valor atual do objeto no DynamoDB, conforme descrito na seção acima.
+ `discard` a mutação. A carga da resposta para essa opção deve ter a seguinte estrutura:
```
{
"action": "discard"
}
```
Isso faz com que a função do AWS AppSync DynamoDB ignore silenciosamente a falha na verificação da condição e retorne o valor no DynamoDB.
+ `retry` a mutação. A carga da resposta para essa opção deve ter a seguinte estrutura:
```
{
"action": "retry",
"retryMapping": { ... }
}
```
Isso faz com que a AWS AppSync função do DynamoDB repita a mutação com um novo objeto de solicitação. A estrutura da seção `retryMapping` depende da operação do DynamoDB e é um subconjunto do objeto da solicitação completo para essa operação.
Em `PutItem`, a seção `retryMapping` tem a seguinte estrutura. Para obter uma descrição do `attributeValues` campo, consulte [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-putitem).
```
{
"attributeValues": { ... },
"condition": {
"equalsIgnore" = [ ... ],
"consistentRead" = true
}
}
```
Em `UpdateItem`, a seção `retryMapping` tem a seguinte estrutura. Para obter uma descrição da `update` seção, consulte [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem).
```
{
"update" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"condition": {
"consistentRead" = true
}
}
```
Em `DeleteItem`, a seção `retryMapping` tem a seguinte estrutura.
```
{
"condition": {
"consistentRead" = true
}
}
```
Não há como especificar uma operação ou chave diferente na qual trabalhar. A função AWS AppSync DynamoDB só permite novas tentativas da mesma operação no mesmo objeto. Além disso, a seção `condition` não permite que um `conditionalCheckFailedHandler` seja especificado. Se a nova tentativa falhar, a função do AWS AppSync DynamoDB segue a estratégia. `Reject`
Veja aqui um exemplo de função do Lambda para lidar com uma solicitação `PutItem` com falha. A lógica de negócios analisa quem fez a chamada. Se foi feita pelo `jeffTheAdmin`, ela tentará novamente a solicitação, atualizando `version` e `expectedVersion` do item atualmente no DynamoDB. Caso contrário, ela rejeitará a mutação.
```
exports.handler = (event, context, callback) => {
console.log("Event: "+ JSON.stringify(event));
// Business logic goes here.
var response;
if ( event.identity.user == "jeffTheAdmin" ) {
response = {
"action" : "retry",
"retryMapping" : {
"attributeValues" : event.requestMapping.attributeValues,
"condition" : {
"expression" : event.requestMapping.condition.expression,
"expressionValues" : event.requestMapping.condition.expressionValues
}
}
}
response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version
} else {
response = { "action" : "reject" }
}
console.log("Response: "+ JSON.stringify(response))
callback(null, response)
};
```
# Expressões de condição da transação
As expressões de condição da transação estão disponíveis em solicitações de todos os quatro tipos de operações em `TransactWriteItems`, ou seja, `PutItem`, `DeleteItem`, `UpdateItem` e `ConditionCheck`.
Em `PutItem`, `DeleteItem` e `UpdateItem`, a expressão de condição da transação é opcional. Em `ConditionCheck`, a expressão de condição da transação é necessária.
## Exemplo 1
A função transacional `DeleteItem` a seguir não tem uma expressão de condição. Como resultado, ele exclui o item no DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
}
],
};
}
```
## Exemplo 2
O manipulador da solicitação da função transacional `DeleteItem` a seguir possui uma expressão de condição da transação que permite que a operação seja bem-sucedida apenas se o autor dessa postagem for igual a determinado nome.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId, authorName} = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
condition: util.transform.toDynamoDBConditionExpression({
authorName: { eq: authorName },
}),
}
],
};
}
```
Se a verificação de condição falhar, causará `TransactionCanceledException` e os detalhes de erro serão retornados em `ctx.result.cancellationReasons`. Observe que, por padrão, o item antigo no DynamoDB que fez a verificação da condição falhar será retornado em `ctx.result.cancellationReasons`.
## Especificação de uma condição
Os objetos da solicitação `PutItem`, `UpdateItem` e `DeleteItem` permitem que uma seção `condition` opcional seja especificada. Se omitida, nenhuma verificação de condição é feita. Se especificada, a condição deve ser verdadeira para que a operação seja bem-sucedida. A `ConditionCheck` deve ter uma seção `condition` a ser especificada. A condição deve ser verdadeira para que toda a transação seja bem-sucedida.
A seção `condition` tem a seguinte estrutura:
```
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: string };
returnValuesOnConditionCheckFailure: boolean;
};
```
Os campos a seguir especificam a condição:
** `expression` **
A própria expressão de atualização. Para obter mais informações sobre como escrever expressões condicionais, consulte a documentação do [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Esse campo deve ser especificado.
** `expressionNames` **
As substituições para espaços reservados de nome do atributo da expressão, na forma de pares de chave/valor. A chave corresponde a um espaço reservado de nome usado na *expressão* e o valor deve ser uma string que corresponde ao nome do atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados na *expressão*.
** `expressionValues` **
As substituições para espaços reservados de valor do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de valor usado na expressão e o valor deve ser um valor digitado. Para obter mais informações sobre como especificar um "valor digitado", consulte [Sistema de tipo (Mapeamento de solicitação)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Isso deve ser especificado. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de valor do atributo da expressão usados na expressão.
** `returnValuesOnConditionCheckFailure` **
Especifique se deseja recuperar o item no DynamoDB quando houver falha na verificação de condição. O item recuperado estará em `ctx.result.cancellationReasons[].item`, onde `` é o índice do item de solicitação cuja verificação de condição falhou. Esse valor padrão é verdadeiro.
# Projeções
Ao ler objetos no DynamoDB usando as operações `GetItem`, `Scan`, `Query`, `BatchGetItem` e `TransactGetItems`, você pode, opcionalmente, especificar uma projeção que identifique os atributos desejados. A propriedade da projeção tem a seguinte estrutura, que é semelhante aos filtros:
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string}
};
```
Os campos são definidos da seguinte forma:
** `expression` **
A expressão de projeção, que é uma string. Para recuperar um único atributo, especifique o seu nome. Para vários atributos, os nomes devem ser valores separados por vírgulas. Para obter mais informações sobre como escrever expressões de projeção, consulte a documentação das [expressões de projeção do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Este campo é obrigatório.
** `expressionNames` **
As substituições para espaços reservados de *nome* do atributo da expressão, na forma de pares chave-valor. A chave corresponde a um espaço reservado de nome usado na `expression`. O valor deve ser uma string que corresponde ao nome de atributo do item no DynamoDB. Esse campo é opcional e deve ser preenchido apenas por substituições para espaços reservados de nome do atributo da expressão usados em `expression`. Para obter mais informações sobre `expressionNames`, consulte a [documentação do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html).
## Exemplo 1
O exemplo a seguir é uma seção de projeção de uma JavaScript função na qual somente os atributos `author` e s `id` são retornados do DynamoDB:
```
projection : {
expression : "#author, id",
expressionNames : {
"#author" : "author"
}
}
```
**dica**
Você pode acessar seu conjunto de seleção de solicitações do GraphQL usando. [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js) Esse campo permite que você ajuste sua expressão de projeção dinamicamente de acordo com seus requisitos.
**nota**
Ao usar expressões de projeção com as operações `Scan` e `Query`, o valor de `select` deve ser `SPECIFIC_ATTRIBUTES`. Para obter mais informações, consulte a [documentação do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).