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 referência do resolvedor (JavaScript)
As seções a seguir contêm a referência do `APPSYNC_JS` tempo de execução e do JavaScript resolvedor:
+ [ JavaScriptvisão geral dos resolvedores](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) - Saiba mais sobre como os resolvedores funcionam em. AWS AppSync
+ [Referência do objeto de contexto do resolvedor](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html): saiba mais sobre o objeto de contexto e como ele é usado em resolvedores.
+ [ JavaScript recursos de tempo de execução para resolvedores e funções](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) - Saiba mais sobre os recursos de tempo de execução compatíveis e o uso de utilitários para simplificar o código.
+ [ JavaScriptreferência da função de resolução para o DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) - Saiba mais sobre como os resolvedores interagem com o DynamoDB.
+ [ JavaScriptreferência da função de resolução para OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-elasticsearch-js.html) - Saiba mais sobre a estrutura de solicitações e respostas do resolvedor e as interações com o OpenSearch Serviço.
+ [ JavaScript Referência da função de resolução para Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html) - Saiba mais sobre a estrutura de solicitações e respostas do resolvedor e as interações com o Lambda.
+ [ JavaScriptreferência da função de resolução para fonte de EventBridge dados](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-eventbridge-js.html) - Saiba mais sobre a estrutura de solicitação e resposta do resolvedor e as interações com EventBridge o.
+ [ JavaScript referência da função de resolução para nenhuma fonte de dados](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-none-js.html) - Saiba mais sobre a estrutura de solicitação e resposta do resolvedor e as interações com nenhuma fonte de dados.
+ [ JavaScript referência da função de resolução para HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-http-js.html) - Saiba mais sobre a estrutura de solicitação e resposta do resolvedor e as interações com endpoints HTTP.
+ [ JavaScript referência da função de resolução para Amazon RDS](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-rds-js.html) - Saiba mais sobre a estrutura do resolvedor e as interações com o RDS.
+ [ JavaScript referência da função de resolução para o Amazon Bedrock](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-bedrock-js.html) - Saiba mais sobre a estrutura do resolvedor e as interações com o Amazon Bedrock.
# AWS AppSync JavaScript visão geral dos resolvedores
AWS AppSync permite que você responda às solicitações do GraphQL executando operações em suas fontes de dados. Para cada campo do GraphQL em que você deseja executar uma consulta, mutação ou assinatura, um resolvedor deve ser anexado.
Os resolvedores são os conectores entre o GraphQL e uma fonte de dados. Eles explicam AWS AppSync como traduzir uma solicitação recebida do GraphQL em instruções para sua fonte de dados de back-end e como traduzir a resposta dessa fonte de dados em uma resposta do GraphQL. Com AWS AppSync, você pode escrever seus resolvedores usando JavaScript e executá-los no ambiente AWS AppSync (`APPSYNC_JS`).
AWS AppSync permite escrever resolvedores de unidades ou resolvedores de pipeline compostos por várias AWS AppSync funções em um pipeline.
## Atributos compatíveis de runtime
O AWS AppSync JavaScript tempo de execução fornece um subconjunto de JavaScript bibliotecas, utilitários e recursos. Para obter uma lista completa dos recursos e funcionalidades suportados pelo tempo de `APPSYNC_JS` execução, consulte [recursos JavaScript de tempo de execução para resolvedores e funções](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html).
## Resolvedores de unidade
Um resolvedor de unidade é composto de código que define um único manipulador de solicitação e resposta que é executado em uma fonte de dados. O manipulador da solicitação usa um objeto de contexto como argumento e retorna o payload da solicitação usado para chamar sua fonte de dados. O manipulador de respostas recebe uma payload da fonte de dados com o resultado da solicitação executada. O manipulador de resposta transforma o payload em uma resposta do GraphQL para resolver o campo GraphQL. No exemplo abaixo, um resolvedor recupera um item de uma fonte de dados do DynamoDB:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.get({ key: { id: ctx.args.id } });
}
export const response = (ctx) => ctx.result;
```
## Anatomia de um resolvedor de JavaScript pipeline
Um resolvedor de pipeline é composto de código que define um manipulador de solicitação e resposta e uma lista de funções. Cada função possui um manipulador de **solicitação** e **resposta** que é executado em uma fonte de dados. Como um resolvedor de pipeline delega a execução a uma lista de funções, ele não está vinculado a nenhuma fonte de dados. Os resolvedores de unidade e funções que executam a operação mediante fontes de dados são primitivos.
### Manipulador de solicitações do resolvedor de pipeline
O manipulador de solicitação de um resolvedor de pipeline, ou etapa Anterior, permite executar uma lógica de preparação antes de executar as funções definidas.
### Lista de funções
A lista de funções que um resolvedor de pipeline executará em sequência. O resultado do manipulador da solicitação do resolvedor de pipeline é disponibilizado para a primeira função como `ctx.prev.result`. Cada resultado da avaliação da função está disponível para a próxima função como `ctx.prev.result`.
### Manipulador de resposta do resolvedor de pipeline
O modelo de resposta de um resolvedor de pipeline permite executar uma lógica final na saída da última função para o tipo de campo do GraphQL esperado. A saída da última função na lista de funções está disponível no manipulador de resposta do resolvedor de pipeline, como `ctx.prev.result` ou `ctx.result`.
### Fluxo de execução
Considerando um resolvedor de pipeline composto de duas funções, a lista abaixo representa o fluxo de execução quando o resolvedor é invocado:
1. Manipulador de solicitações do resolvedor de pipeline
1. Função 1: manipulador de solicitação de função
1. Função 1: invocação da fonte de dados
1. Função 1: manipulador de resposta de função
1. Função 2: manipulador de solicitação de função
1. Função 2: invocação da fonte de dados
1. Função 2: manipulador de resposta de função
1. Manipulador de resposta do resolvedor de pipeline
![\[GraphQL request flow diagram showing interactions between request, data sources, and response components.\]](http://docs.aws.amazon.com/pt_br/appsync/latest/devguide/images/appsync-js-resolver-logic.png)
### Utilitários integrados úteis do runtime `APPSYNC_JS`
Os utilitários a seguir podem ajudá-lo quando você estiver trabalhando com resolvedores de pipeline.
#### ctx.stash
O stash é um objeto disponibilizado dentro de cada manipulador de resposta e solicitação de resolvedor e função. A mesma instância stash passa por uma única execução do resolvedor. Isso significa que é possível usar o stash para enviar dados arbitrários entre os manipuladores de solicitações e respostas e entre as funções em um resolvedor de pipeline. Você pode testar o estoque como um JavaScript objeto normal.
#### ctx.prev.result
O `ctx.prev.result` representa o resultado da operação anterior que foi executada no pipeline. Se a operação anterior foi o manipulador de solicitações do resolvedor de pipeline, `ctx.prev.result` será disponibilizado para a primeira função no encadeamento. Se a operação anterior foi a primeira função, `ctx.prev.result` representa a saída da primeira função e será disponibilizado para a segunda função no pipeline. Se a operação anterior foi a última função, `ctx.prev.result` representa a saída da última função e será disponibilizado para o manipulador de resposta do resolvedor de pipeline.
#### util.error
O utilitário `util.error` é útil para gerar um erro de campo. Usar `util.error` dentro de um manipulador de solicitação ou resposta de função gera um erro de campo imediatamente, o que impede que funções subsequentes sejam executadas. Para obter mais detalhes e outras `util.error` assinaturas, visite [recursos de JavaScript tempo de execução para resolvedores e](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) funções.
#### util.appendError
O `util.appendError` é semelhante a `util.error()`, com a principal distinção de que ele não interrompe a avaliação do manipulador. Em vez disso, ele sinaliza que ocorreu um erro com o campo, mas permite que o manipulador seja avaliado e, consequentemente, retorne dados. Usar `util.appendError` dentro de uma função não interromperá o fluxo de execução do pipeline. Para obter mais detalhes e outras `util.error` assinaturas, visite os [recursos de JavaScript tempo de execução para resolvedores e](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) funções.
#### runtime.earlyReturn
A função `runtime.earlyReturn` permite que você gere resultados prematuramente para qualquer função de solicitação. Usar `runtime.earlyReturn` em um manipulador de solicitações do resolvedor retornará resultados do resolvedor. Chamá-lo em um manipulador de solicitação de função AWS AppSync retornará resultados a partir da função e continuará a execução até a próxima função no pipeline ou o manipulador de resposta do resolvedor.
### Escrever resolvedores de pipeline
Um resolvedor de pipeline também tem um manipulador de solicitação e resposta para a execução das funções no pipeline: o manipulador de solicitação é executado antes da solicitação da primeira função, e o manipulador de resposta é executado após a resposta da última função. O manipulador de solicitação do resolvedor pode configurar dados para serem usados pelas funções no pipeline. O manipulador de resposta do resolvedor é responsável por retornar dados que são mapeados para o tipo de saída do campo GraphQL. No exemplo abaixo, um manipulador de solicitação do resolvedor define `allowedGroups`; os dados retornados devem pertencer a um desses grupos. Esse valor pode ser usado pelas funções do resolvedor para solicitar dados. O manipulador de resposta do resolvedor realiza uma verificação final e filtra o resultado para garantir que somente os itens que pertencem aos grupos permitidos sejam retornados.
```
import { util } from '@aws-appsync/utils';
/**
* Called before the request function of the first AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
ctx.stash.allowedGroups = ['admin'];
ctx.stash.startedAt = util.time.nowISO8601();
return {};
}
/**
* Called after the response function of the last AppSync function in the pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const result = [];
for (const item of ctx.prev.result) {
if (ctx.stash.allowedGroups.indexOf(item.group) > -1) result.push(item);
}
return result;
}
```
#### AWS AppSync Funções de escrita
AWS AppSync as funções permitem que você escreva uma lógica comum que você pode reutilizar em vários resolvedores em seu esquema. Por exemplo, você pode ter uma AWS AppSync função chamada `QUERY_ITEMS` responsável por consultar itens de uma fonte de dados do Amazon DynamoDB. Para resolvedores com os quais você gostaria de consultar itens, basta adicionar a função ao pipeline do resolvedor e fornecer o índice de consulta a ser usado. A lógica não precisa ser reimplementada.
## Tópicos complementares
**Tópicos**
+ [Exemplo de resolvedor de pipeline com o Amazon DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/writing-code.html)
+ [Configuração de utilitários para o runtime do `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/utility-resolvers.html)
+ [Agrupamento e mapas TypeScript de origem para o tempo de execução `APPSYNC_JS`](https://docs.aws.amazon.com/appsync/latest/devguide/additional-utilities.html)
+ [Como testar seu resolvedor e manipuladores de função](https://docs.aws.amazon.com/appsync/latest/devguide/test-resolvers.html)
+ [Migrando da VTL para JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/migrating-resolvers.html)
+ [Escolha entre acesso direto à fonte de dados e proxy por meio de uma fonte de dados do Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/choosing-data-source.html)
# Exemplo de resolvedor de pipeline com o Amazon DynamoDB
Digamos que você queira anexar um resolvedor de pipeline em um campo chamado `getPost(id:ID!)` que retorna o tipo `Post` de uma fonte de dados do Amazon DynamoDB com a seguinte consulta do GraphQL:
```
getPost(id:1){
id
title
content
}
```
Primeiro, anexe um resolvedor simples a `Query.getPost` com o código abaixo. Este é um exemplo de código de resolvedor simples. Não há lógica definida no manipulador de solicitação, e o manipulador de resposta simplesmente retorna o resultado da última função.
```
/**
* Invoked **before** the request handler of the first AppSync function in the pipeline.
* The resolver `request` handler allows to perform some preparation logic
* before executing the defined functions in your pipeline.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
return {}
}
/**
* Invoked **after** the response handler of the last AppSync function in the pipeline.
* The resolver `response` handler allows to perform some final evaluation logic
* from the output of the last function to the expected GraphQL field type.
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
return ctx.prev.result
}
```
Em seguida, defina a função `GET_ITEM` que recupera um postItem da sua fonte de dados:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
/**
* Request a single item from the attached DynamoDB table datasource
* @param ctx the context object holds contextual information about the function invocation.
*/
export function request(ctx) {
const { id } = ctx.args
return ddb.get({ key: { id } })
}
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx
if (error) {
return util.appendError(error.message, error.type, result)
}
return ctx.result
}
```
Se houver um erro durante a solicitação, o manipulador de resposta da função anexará no final um erro que será retornado ao cliente chamador na resposta do GraphQL. Adicione a função `GET_ITEM` à sua lista de funções do resolvedor. Quando você executa a consulta, o manipulador de solicitações da `GET_ITEM` função usa os utilitários fornecidos pelo módulo AWS AppSync DynamoDB para criar uma `DynamoDBGetItem` solicitação usando o como chave. `id` `ddb.get({ key: { id } })`gera a `GetItem` operação apropriada:
```
{
"operation" : "GetItem",
"key" : {
"id" : { "S" : "1" }
}
}
```
AWS AppSync usa a solicitação para buscar os dados do Amazon DynamoDB. Depois que os dados são retornados, eles são tratados pelo manipulador de resposta da função `GET_ITEM`, que verifica erros e retorna o resultado.
```
{
"result" : {
"id": 1,
"title": "hello world",
"content": ""
}
}
```
Finalmente, o manipulador de resposta do resolvedor retorna o resultado diretamente.
## Como trabalhar com eventos
Se ocorrer um erro na sua função durante uma solicitação, ele será disponibilizado no manipulador de resposta da função em `ctx.error`. Você pode acrescentar o erro no final da sua resposta do GraphQL usando o utilitário `util.appendError`. É possível disponibilizar o erro para outras funções no pipeline usando o stash. Veja o exemplo abaixo:
```
/**
* Returns the result
* @param ctx the context object holds contextual information about the function invocation.
*/
export function response(ctx) {
const { error, result } = ctx;
if (error) {
if (!ctx.stash.errors) ctx.stash.errors = []
ctx.stash.errors.push(ctx.error)
return util.appendError(error.message, error.type, result);
}
return ctx.result;
}
```
# Configuração de utilitários para o runtime do `APPSYNC_JS`
AWS AppSync fornece duas bibliotecas que auxiliam no desenvolvimento de resolvedores com o `APPSYNC_JS` tempo de execução:
+ `@aws-appsync/eslint-plugin`: detecta e corrige problemas rapidamente durante o desenvolvimento.
+ `@aws-appsync/utils`: fornece validação de tipo e preenchimento automático em editores de código.
## Configurar o plug-in eslint
[ESLint](https://eslint.org/)é uma ferramenta que analisa estaticamente seu código para encontrar problemas rapidamente. Você pode executar ESLint como parte do seu pipeline de integração contínua. `@aws-appsync/eslint-plugin`é um ESLint plug-in que captura a sintaxe inválida em seu código ao aproveitar o tempo de execução. `APPSYNC_JS` O plug-in permite que você receba rapidamente feedback sobre seu código durante o desenvolvimento sem precisar enviar suas alterações para a nuvem.
`@aws-appsync/eslint-plugin` fornece dois conjuntos de regras que você pode usar durante o desenvolvimento.
**“plugin:@aws-appsync/base”** configura um conjunto básico de regras que você pode aproveitar no seu projeto:
| Rule | Description |
| --- | --- |
| no-async | Promessas e processos assíncronos não são compatíveis. |
| no-await | Promessas e processos assíncronos não são compatíveis. |
| no-classes | Classes não são compatíveis. |
| no-for | for não é compatível (exceto para for-in e for-of, que são aceitos) |
| no-continue | Não há suporte ao continue. |
| no-generators | Geradores não são compatíveis. |
| no-yield | Não há suporte ao yield. |
| no-labels | Rótulos não são compatíveis. |
| no-this | A palavra-chave this não é compatível. |
| no-try | A estrutura try/catch não é compatível. |
| no-while | Loops While não são compatíveis. |
| no-disallowed-unary-operators | Operadores unários \$1\$1, -- e \$1 não são compatíveis. |
| no-disallowed-binary-operators | O operador instanceof não é compatível. |
| no-promise | Promessas e processos assíncronos não são compatíveis. |
**“plugin: @aws -appsync/recommended”** fornece algumas regras adicionais, mas também exige que você adicione TypeScript configurações ao seu projeto.
| Rule | Description |
| --- | --- |
| no-recursion | Chamadas de função recursivas não são compatíveis |
| no-disallowed-methods | Alguns métodos não são compatíveis. Consulte a [referência](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference-js.html) para obter um conjunto completo de funções integradas compatíveis. |
| no-function-passing | Não é permitido enviar funções como argumentos de função para funções. |
| no-function-reassign | As funções não podem ser reatribuídas. |
| no-function-return | As funções não podem ser o valor de retorno das funções. |
Para adicionar o plug-in ao seu projeto, siga as etapas de instalação e uso em [Introdução ao ESLint](https://eslint.org/docs/latest/user-guide/getting-started#installation-and-usage). Em seguida, instale o [plug-in](https://www.npmjs.com/package/@aws-appsync/eslint-plugin) no seu projeto usando o gerenciador de pacotes do projeto (por exemplo, npm, yarn ou pnpm):
```
$ npm install @aws-appsync/eslint-plugin
```
No seu arquivo `.eslintrc.{js,yml,json}`, adicione **“plugin:@aws-appsync/base”** ou **“plugin:@aws-appsync/recommended**” à propriedade `extends`. O trecho abaixo é um exemplo básico de `.eslintrc` configuração para: JavaScript
```
{
"extends": ["plugin:@aws-appsync/base"]
}
```
Para usar o conjunto de regras **“plugin:@aws-appsync/recommended”**, instale a dependência necessária:
```
$ npm install -D @typescript-eslint/parser
```
Depois, crie um arquivo `.eslintrc.js`:
```
{
"parser": "@typescript-eslint/parser",
"parserOptions": {
"ecmaVersion": 2018,
"project": "./tsconfig.json"
},
"extends": ["plugin:@aws-appsync/recommended"]
}
```
# Agrupamento e mapas TypeScript de origem para o tempo de execução `APPSYNC_JS`
TypeScript aprimora AWS AppSync o desenvolvimento fornecendo segurança de tipo e detecção precoce de erros. Você pode escrever TypeScript código localmente e transpilá-lo JavaScript antes de usá-lo com o `APPSYNC_JS` tempo de execução. O processo começa com a instalação TypeScript e configuração do tsconfig.json para o ambiente. `APPSYNC_JS` Em seguida, é possível utilizar ferramentas de empacotamento, como a esbuild, para compilar e empacotar o código. A CLI do Amplify gerará tipos do esquema GraphQL, permitindo que você use esses tipos no código do resolvedor.
No seu resolvedor e código de função, você pode aproveitar bibliotecas personalizadas e externas, desde que estejam em conformidade com os requisitos do `APPSYNC_JS`. As ferramentas de agrupamento combinam código em um único arquivo para uso em AWS AppSync. Os mapas de origem podem ser incluídos para ajudar na depuração.
## Aproveitar as bibliotecas e empacotar seu código
No seu resolvedor e código de função, você pode aproveitar bibliotecas personalizadas e externas, desde que estejam em conformidade com os requisitos de `APPSYNC_JS`. Isso possibilita a reutilização do código existente na sua aplicação. Para usar bibliotecas definidas por vários arquivos, você deve usar uma ferramenta de agrupamento, como [esbuild](https://esbuild.github.io/), para combinar seu código em um único arquivo que pode ser salvo em seu AWS AppSync resolvedor ou função.
Ao empacotar o código, lembre-se do seguinte:
+ `APPSYNC_JS`suporta apenas ECMAScript módulos (ESM).
+ Os módulos `@aws-appsync/*` são integrados em `APPSYNC_JS` e não devem ser empacotados com seu código.
+ O ambiente de runtime `APPSYNC_JS` é semelhante ao NodeJS, pois o código não é executado em um ambiente de navegador.
+ Você pode incluir um mapa de origem opcional. No entanto, não inclua o conteúdo original.
Para saber mais sobre mapas de origem, consulte [Usar mapas de origem](#source-maps).
Por exemplo, para empacotar o código do resolvedor localizado em `src/appsync/getPost.resolver.js`, é possível usar o seguinte comando CLI esbuild:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/getPost.resolver.js
```
## Criando seu código e trabalhando com TypeScript
[TypeScript](https://www.typescriptlang.org/)é uma linguagem de programação desenvolvida pela Microsoft que oferece todos os JavaScript recursos junto com o sistema de TypeScript digitação. Você pode usar TypeScript para escrever código de tipo seguro e capturar erros e bugs no momento da compilação antes de salvar seu código no. AWS AppSync O pacote `@aws-appsync/utils` está totalmente inserido.
O `APPSYNC_JS` tempo de execução não oferece suporte TypeScript direto. Primeiro, você deve transpilar seu TypeScript código para um JavaScript código compatível com o `APPSYNC_JS` tempo de execução antes de salvá-lo. AWS AppSync Você pode usar TypeScript para escrever seu código em seu ambiente de desenvolvimento integrado (IDE) local, mas observe que você não pode criar TypeScript código no AWS AppSync console.
Para começar, verifique se você [TypeScript](https://www.typescriptlang.org/download)instalou em seu projeto. Em seguida, defina suas configurações de TypeScript transcompilação para trabalhar com o `APPSYNC_JS` tempo de execução usando. [TSConfig](https://www.typescriptlang.org/tsconfig) Aqui está um exemplo de um arquivo básico `tsconfig.json` que você pode usar:
```
// tsconfig.json
{
"compilerOptions": {
"target": "esnext",
"module": "esnext",
"noEmit": true,
"moduleResolution": "node",
}
}
```
Em seguida, é possível utilizar uma ferramenta de empacotamento como esbuild para compilar e agrupar seu código. Por exemplo, em um projeto com seu AWS AppSync código localizado em`src/appsync`, você pode usar o comando a seguir para compilar e agrupar seu código:
```
$ esbuild --bundle \
--sourcemap=inline \
--sources-content=false \
--target=esnext \
--platform=node \
--format=esm \
--external:@aws-appsync/utils \
--outdir=out/appsync \
src/appsync/**/*.ts
```
### Usar o codegen Amplify
Você pode usar a [CLI do Amplify](https://docs.amplify.aws/cli/) para gerar os tipos para seu esquema. No diretório em que seu arquivo `schema.graphql` está localizado, execute o comando a seguir e revise os prompts para configurar seu codegen:
```
$ npx @aws-amplify/cli codegen add
```
Para regenerar seu codegen em determinadas circunstâncias (por exemplo, quando seu esquema é atualizado), execute o seguinte comando:
```
$ npx @aws-amplify/cli codegen
```
Em seguida, é possível usar os tipos gerados no código do resolvedor. Por exemplo, considerando o seguinte esquema:
```
type Todo {
id: ID!
title: String!
description: String
}
type Mutation {
createTodo(title: String!, description: String): Todo
}
type Query {
listTodos: Todo
}
```
Você pode usar os tipos gerados na seguinte AWS AppSync função de exemplo:
```
import { Context, util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
import { CreateTodoMutationVariables, Todo } from './API' // codegen
export function request(ctx: Context) {
ctx.args.description = ctx.args.description ?? 'created on ' + util.time.nowISO8601()
return ddb.put({ key: { id: util.autoId() }, item: ctx.args })
}
export function response(ctx) {
return ctx.result as Todo
}
```
### Usando genéricos em TypeScript
Você pode usar genéricos com vários dos tipos fornecidos. Por exemplo, o trecho abaixo é do tipo `Todo`:
```
export type Todo = {
__typename: "Todo",
id: string,
title: string,
description?: string | null,
};
```
Você pode escrever um resolvedor para uma assinatura que use `Todo`. No seu IDE, as definições de tipo e as dicas de preenchimento automático orientarão você a usar corretamente o utilitário de transformação `toSubscriptionFilter`:
```
import { util, Context, extensions } from '@aws-appsync/utils'
import { Todo } from './API'
export function request(ctx: Context) {
return {}
}
export function response(ctx: Context) {
const filter = util.transform.toSubscriptionFilter({
title: { beginsWith: 'hello' },
description: { contains: 'created' },
})
extensions.setSubscriptionFilter(filter)
return null
}
```
## Usar Lint nos seus pacotes
Você pode filtrar automaticamente seus pacotes importando o plug-in `esbuild-plugin-eslint`. Em seguida, você pode ativá-lo fornecendo um valor `plugins` que ative os recursos do eslint. Abaixo está um trecho que usa a JavaScript API esbuild em um arquivo chamado: `build.mjs`
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
## Usar mapas de origem
Você pode fornecer um mapa de origem embutido (`sourcemap`) com seu JavaScript código. Os mapas de origem são úteis para quando você agrupa JavaScript ou TypeScript codifica e deseja ver referências aos seus arquivos de origem de entrada em seus registros e mensagens de JavaScript erro de tempo de execução.
Seu `sourcemap` deve aparecer no final do seu código. Ele é definido por uma única linha de comentário que segue o seguinte formato:
```
//# sourceMappingURL=data:application/json;base64,
```
Veja um exemplo abaixo:
```
//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsibGliLmpzIiwgImNvZGUuanMiXSwKICAibWFwcGluZ3MiOiAiO0FBQU8sU0FBUyxRQUFRO0FBQ3RCLFNBQU87QUFDVDs7O0FDRE8sU0FBUyxRQUFRLEtBQUs7QUFDM0IsU0FBTyxNQUFNO0FBQ2Y7IiwKICAibmFtZXMiOiBbXQp9Cg==
```
Os mapas de origem podem ser criados com o esbuild. O exemplo abaixo mostra como usar a JavaScript API esbuild para incluir um mapa de origem embutido quando o código é criado e agrupado:
```
/* eslint-disable */
import { build } from 'esbuild'
import eslint from 'esbuild-plugin-eslint'
import glob from 'glob'
const files = await glob('src/**/*.ts')
await build({
sourcemap: 'inline',
sourcesContent: false,
format: 'esm',
target: 'esnext',
platform: 'node',
external: ['@aws-appsync/utils'],
outdir: 'dist/',
entryPoints: files,
bundle: true,
plugins: [eslint({ useEslintrc: true })],
})
```
Em particular, as opções `sourcesContent` e `sourcemap` especificam que um mapa de origem deve ser adicionado in-line no final de cada compilação, mas não deve incluir o conteúdo de origem. Como convenção, recomendamos não incluir o conteúdo de origem em `sourcemap`. É possível desativar isso no esbuild definindo `sources-content` como `false`.
Para ilustrar como os mapas de origem funcionam, revise o exemplo a seguir em que um código de resolvedor faz referência a funções de ajuda de uma biblioteca de ajuda. O código contém instruções de log no código do resolvedor e na biblioteca de ajuda:
**./src/default.resolver.ts** (seu resolvedor)
```
import { Context } from '@aws-appsync/utils'
import { hello, logit } from './helper'
export function request(ctx: Context) {
console.log('start >')
logit('hello world', 42, true)
console.log('< end')
return 'test'
}
export function response(ctx: Context): boolean {
hello()
return ctx.prev.result
}
```
**.src/helper.ts** (um arquivo auxiliar)
```
export const logit = (...rest: any[]) => {
// a special logger
console.log('[logger]', ...rest.map((r) => `<${r}>`))
}
export const hello = () => {
// This just returns a simple sentence, but it could do more.
console.log('i just say hello..')
}
```
Ao criar e empacotar o arquivo resolvedor, seu código do resolvedor incluirá um mapa de origem in-line. Quando seu resolvedor é executado, as seguintes entradas aparecem nos CloudWatch registros:
![\[CloudWatch log entries showing resolver code execution with inline source map information.\]](http://docs.aws.amazon.com/pt_br/appsync/latest/devguide/images/cloudwatch-sourcemap.jpeg)
Observando as entradas no CloudWatch registro, você notará que a funcionalidade dos dois arquivos foi agrupada e está sendo executada simultaneamente. O nome do arquivo original de cada arquivo também é claramente refletido nos registros.
# Testando seu resolvedor e manipuladores de funções em AWS AppSync
Você pode usar o comando da API `EvaluateCode` para testar remotamente seu resolvedor e manipuladores de funções com dados simulados antes mesmo de salvar seu código em um resolvedor ou função. Para começar a usar o comando, certifique-se de ter adicionado a permissão `appsync:evaluatecode` à sua política. Por exemplo:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
Você pode aproveitar o comando usando a [AWS CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/index.html) ou. [AWS SDKs](https://aws.amazon.com/tools/) Por exemplo, para testar seu código usando a CLI, basta apontar para o arquivo, fornecer um contexto e especificar o manipulador que você deseja avaliar:
```
aws appsync evaluate-code \
--code file://code.js \
--function request \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
A resposta tem um `evaluationResult` contendo o payload retornada pelo seu manipulador. Também contém um objeto `logs` com a lista de logs que foram gerados pelo seu manipulador durante a avaliação. Isso facilita a depuração da execução do código e a visualização de informações sobre sua avaliação para ajudar na solução de problemas. Por exemplo:
```
{
"evaluationResult": "{\"operation\":\"PutItem\",\"key\":{\"id\":{\"S\":\"record-id\"}},\"attributeValues\":{\"owner\":{\"S\":\"John doe\"},\"expectedVersion\":{\"N\":2},\"authorId\":{\"S\":\"Sammy Davis\"}}}",
"logs": [
"INFO - code.js:5:3: \"current id\" \"record-id\"",
"INFO - code.js:9:3: \"request evaluated\""
]
}
```
O resultado da avaliação pode ser analisado como JSON, que fornece:
```
{
"operation": "PutItem",
"key": {
"id": {
"S": "record-id"
}
},
"attributeValues": {
"owner": {
"S": "John doe"
},
"expectedVersion": {
"N": 2
},
"authorId": {
"S": "Sammy Davis"
}
}
}
```
Usando o SDK, você pode incorporar facilmente testes do seu conjunto de testes para validar o comportamento do código. Este exemplo usa o [Jest Testing Framework](https://jestjs.io/), mas qualquer conjunto de testes funciona. O trecho a seguir mostra uma execução de validação hipotética. Esperamos que a resposta de avaliação seja um JSON válido, por isso, usamos `JSON.parse` para recuperar o JSON da resposta da string:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Isso produz o seguinte resultado:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
# Migrando da VTL para a JavaScript AWS AppSync
AWS AppSync permite que você escreva sua lógica de negócios para seus resolvedores e funções usando VTL ou. JavaScript Com as duas linguagens, você escreve uma lógica que instrui o AWS AppSync serviço sobre como interagir com suas fontes de dados. Com o VTL, você grava modelos de mapeamento que devem ser avaliados como uma string válida codificada em JSON. Com JavaScript, você escreve manipuladores de solicitações e respostas que retornam objetos. Você não retorna uma string codificada em JSON.
Por exemplo, use o seguinte modelo de mapeamento de VTL para obter um item do Amazon DynamoDB:
```
{
"operation": "GetItem",
"key": {
"id": $util.dynamodb.toDynamoDBJson($ctx.args.id),
}
}
```
O utilitário `$util.dynamodb.toDynamoDBJson` retorna uma string codificada em JSON. Se `$ctx.args.id` estiver definido como ``, o modelo será avaliado como uma string válida codificada em JSON:
```
{
"operation": "GetItem",
"key": {
"id": {"S": ""},
}
}
```
Ao trabalhar com JavaScript, você não precisa imprimir strings brutas codificadas em JSON em seu código, e usar um utilitário como esse não é necessário. `toDynamoDBJson` Um exemplo equivalente do modelo de mapeamento acima é:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: {id: util.dynamodb.toDynamoDB(ctx.args.id)}
};
}
```
Uma alternativa é usar `util.dynamodb.toMapValues`, que é a abordagem recomendada para manipular um objeto de valores:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'GetItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
É avaliado como:
```
{
"operation": "GetItem",
"key": {
"id": {
"S": ""
}
}
}
```
**nota**
Recomendamos usar o módulo do DynamoDB com as fontes de dados do DynamoDB:
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
ddb.get({ key: { id: ctx.args.id } })
}
```
Por exemplo, use o seguinte modelo de mapeamento para obter um item em uma fonte de dados do Amazon DynamoDB:
```
{
"operation" : "PutItem",
"key" : {
"id": $util.dynamodb.toDynamoDBJson($util.autoId()),
},
"attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```
Quando avaliada, essa string do modelo de mapeamento deve produzir uma string válida codificada em JSON. Ao usar JavaScript, seu código retorna o objeto de solicitação diretamente:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id = util.autoId(), ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
que é avaliado como:
```
{
"operation": "PutItem",
"key": {
"id": { "S": "2bff3f05-ff8c-4ed8-92b4-767e29fc4e63" }
},
"attributeValues": {
"firstname": { "S": "Shaggy" },
"age": { "N": 4 }
}
}
```
**nota**
Recomendamos usar o módulo do DynamoDB com as fontes de dados do DynamoDB:
```
import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
const { id = util.autoId(), ...item } = ctx.args
return ddb.put({ key: { id }, item })
}
```
# Escolha entre acesso direto à fonte de dados e proxy por meio de uma fonte de dados do Lambda
Com AWS AppSync e o `APPSYNC_JS` tempo de execução, você pode escrever seu próprio código que implemente sua lógica de negócios personalizada usando AWS AppSync funções para acessar suas fontes de dados. Isso facilita a interação direta com fontes de dados como Amazon DynamoDB, Aurora OpenSearch Serverless, Service APIs, HTTP AWS e outros serviços sem precisar implantar serviços computacionais ou infraestrutura adicionais. AWS AppSync também facilita a interação com uma AWS Lambda função configurando uma fonte de dados Lambda. As fontes de dados Lambda permitem que você execute uma lógica comercial complexa usando os recursos completos AWS Lambda do conjunto para resolver uma solicitação do GraphQL. Na maioria dos casos, uma AWS AppSync função conectada diretamente à fonte de dados de destino fornecerá todas as funcionalidades de que você precisa. Em situações em que você precisa implementar uma lógica de negócios complexa que não é suportada pelo runtime `APPSYNC_JS`, você pode usar uma fonte de dados do Lambda como proxy para interagir com sua fonte de dados de destino.
| | | |
| --- |--- |--- |
| | Integração direta de fontes de dados | Fonte de dados Lambda como proxy |
| Caso de uso | AWS AppSync as funções interagem diretamente com as fontes de dados da API. | AWS AppSync funções chamadas de Lambdas que interagem com fontes de dados da API. |
| Runtime | APPSYNC\$1JS (JavaScript) | Qualquer tempo de execução Lambda compatível |
| Tamanho máximo do código | 32.000 caracteres por função AWS AppSync | 50 MB (compactado, para upload direto) por Lambda |
| Módulos externos | Limitado - somente recursos compatíveis com o APPSYNC\$1JS | Sim |
| Ligue para qualquer AWS serviço | Sim - Usando a fonte de dados AWS AppSync HTTP | Sim - Usando o AWS SDK |
| Acesso ao cabeçalho da solicitação | Sim | Sim |
| Acesso à rede | Não | Sim |
| Acesso ao sistema de arquivos | Não | Sim |
| Registro e métricas | Sim | Sim |
| Crie e teste inteiramente dentro AppSync | Sim | Não |
| Arranque a frio | Não | Não - Com simultaneidade provisionada |
| Ajuste de escala automático | Sim - de forma transparente por AWS AppSync | Sim - conforme configurado no Lambda |
| Preços | Sem custo adicional | Cobrado pelo uso do Lambda |
AWS AppSync funções que se integram diretamente à fonte de dados de destino são ideais para casos de uso como os seguintes:
+ Interagindo com Amazon DynamoDB, Aurora Serverless e Service OpenSearch
+ Interagindo com HTTP APIs e passando cabeçalhos de entrada
+ Interagindo com AWS serviços usando fontes de dados HTTP (com solicitações de assinatura AWS AppSync automática com a função de fonte de dados fornecida)
+ Implementar o controle de acesso antes de acessar as fontes de dados
+ Implementar a filtragem dos dados recuperados antes de atender a uma solicitação
+ Implementação de orquestração simples com execução sequencial de AWS AppSync funções em um pipeline de resolução
+ Controlar conexões de cache e assinatura em consultas e mutações.
AWS AppSync funções que usam uma fonte de dados Lambda como proxy são ideais para casos de uso como os seguintes:
+ Usando uma linguagem diferente JavaScript da Velocity Template Language (VTL)
+ Ajustar e controlar a CPU ou a memória para otimizar a performance
+ Importar bibliotecas de terceiros ou exigir atributos não suportados no `APPSYNC_JS`
+ Fazer várias solicitações de rede and/or obtendo acesso ao sistema de arquivos para atender a uma consulta
+ Fazer solicitações em lote usando a [configuração em lote](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-lambda-js.html)
# AWS AppSync JavaScript referência de objeto de contexto do resolvedor
AWS AppSync define um conjunto de variáveis e funções para trabalhar com manipuladores de solicitações e respostas. Isso facilita as operações lógicas em dados com o GraphQL. Este documento descreve essas funções e fornece exemplos.
## Acesso ao `context`
O argumento `context` de um manipulador de solicitações e respostas é um objeto que contém todas as informações contextuais para a invocação do seu resolvedor. Ela tem a seguinte estrutura:
```
type Context = {
arguments: any;
args: any;
identity: Identity;
source: any;
error?: {
message: string;
type: string;
};
stash: any;
result: any;
prev: any;
request: Request;
info: Info;
};
```
**nota**
Você descobrirá que o objeto `context` é chamado de `ctx`.
Cada campo no objeto `context` é definido da seguinte forma:
### Campos de `context`
** `arguments` **
Um mapa que contém todos os argumentos do GraphQL para este campo.
** `identity` **
Um objeto que contém informações sobre o chamador. Para obter mais informações sobre a estrutura desse campo, consulte [Identidade](#aws-appsync-resolver-context-reference-identity-js).
** `source` **
Um mapa que contém a resolução do campo pai.
** `stash` **
O stash é um objeto disponibilizado dentro de cada manipulador de resolvedor e função. O mesmo objeto stash subsiste por meio de uma única execução de resolvedor. Isso significa que é possível usar o stash para passar dados arbitrários entre os manipuladores de solicitações e respostas e entre as funções em um resolvedor de pipeline.
Não é possível excluir ou substituir o stash inteiro, mas você pode adicionar, atualizar, excluir e ler as propriedades dele.
Você pode adicionar itens ao stash modificando um dos exemplos de código abaixo:
```
//Example 1
ctx.stash.newItem = { key: "something" }
//Example 2
Object.assign(ctx.stash, {key1: value1, key2: value})
```
Você pode remover itens do stash modificando o código abaixo:
```
delete ctx.stash.key
```
** `result` **
Um contêiner para os resultados desse resolvedor. Esse campo só está disponível para manipuladores de respostas.
Por exemplo, se estiver resolvendo o campo `author` da seguinte consulta:
```
query {
getPost(id: 1234) {
postId
title
content
author {
id
name
}
}
}
```
Então, a variável `context` completa estará disponível quando um manipulador de respostas for avaliado:
```
{
"arguments" : {
id: "1234"
},
"source": {},
"result" : {
"postId": "1234",
"title": "Some title",
"content": "Some content",
"author": {
"id": "5678",
"name": "Author Name"
}
},
"identity" : {
"sourceIp" : ["x.x.x.x"],
"userArn" : "arn:aws:iam::123456789012:user/appsync",
"accountId" : "666666666666",
"user" : "AIDAAAAAAAAAAAAAAAAAA"
}
}
```
** `prev.result` **
O resultado de qualquer operação anterior executada em um resolvedor de pipeline.
Se a operação anterior foi o manipulador de solicitações do resolvedor de pipeline, `ctx.prev.result` representa o resultado da avaliação e será disponibilizado para a primeira função no pipeline.
Se a operação anterior foi a primeira função, `ctx.prev.result` representa o resultado da avaliação do manipulador de respostas da primeira função e será disponibilizado para a segunda função no pipeline.
Se a operação anterior foi a última função, `ctx.prev.result` representa o resultado da avaliação da última função e será disponibilizado para o manipulador de respostas do resolvedor do pipeline.
** `info` **
Um objeto que contém informações sobre a solicitação do GraphQL. Para ver a estrutura desse campo, consulte [Informações](#aws-appsync-resolver-context-reference-info-js).
### Identidade
A seção `identity` contém informações sobre o chamador. O formato dessa seção depende do tipo de autorização da sua AWS AppSync API.
Para obter mais informações sobre as opções de AWS AppSync segurança, consulte [Autorização e autenticação](security-authz.md#aws-appsync-security).
** `API_KEY` authorization**
O campo `identity` não está preenchido.
**`AWS_LAMBDA` authorization**
O `identity` tem o seguinte formato:
```
type AppSyncIdentityLambda = {
resolverContext: any;
};
```
`identity` inclui a chave `resolverContext` que tem o mesmo conteúdo de `resolverContext` retornado pela função do Lambda que autorizou a solicitação.
** `AWS_IAM` authorization**
O `identity` tem o seguinte formato:
```
type AppSyncIdentityIAM = {
accountId: string;
cognitoIdentityPoolId: string;
cognitoIdentityId: string;
sourceIp: string[];
username: string;
userArn: string;
cognitoIdentityAuthType: string;
cognitoIdentityAuthProvider: string;
};
```
** `AMAZON_COGNITO_USER_POOLS` authorization**
O `identity` tem o seguinte formato:
```
type AppSyncIdentityCognito = {
sourceIp: string[];
username: string;
groups: string[] | null;
sub: string;
issuer: string;
claims: any;
defaultAuthStrategy: string;
};
```
Cada campo é definido da seguinte forma:
** `accountId` **
O ID da AWS conta do chamador.
** `claims` **
As reivindicações do usuário.
** `cognitoIdentityAuthType` **
Autenticado ou não autenticado com base no tipo de identidade.
** `cognitoIdentityAuthProvider` **
Uma lista separada por vírgulas das informações do provedor de identidade externo usada na obtenção das credenciais usadas para assinar a solicitação.
** `cognitoIdentityId` **
O ID de identidade do Amazon Cognito do chamador.
** `cognitoIdentityPoolId` **
O ID do banco de identidades do Amazon Cognito associado ao chamador.
** `defaultAuthStrategy` **
A estratégia de autorização padrão para este chamador (`ALLOW` ou `DENY`).
** `issuer` **
O emissor do token.
** `sourceIp` **
O endereço IP de origem do chamador que AWS AppSync recebe. Se a solicitação não incluir o cabeçalho `x-forwarded-for`, o valor do IP de origem conterá apenas um único endereço IP da conexão TCP. Se a solicitação inclui um cabeçalho `x-forwarded-for`, o IP de origem será uma lista de endereços IP do cabeçalho `x-forwarded-for`, além do endereço IP da conexão TCP.
** `sub` **
O UUID do usuário autenticado.
** `user` **
O usuário do IAM.
** `userArn` **
O nome do recurso da Amazon (ARN) do usuário do IAM.
** `username` **
O nome do usuário autenticado. Em caso de autorização `AMAZON_COGNITO_USER_POOLS`, o valor do nome de usuário é o valor de *username* é o valor do atributo *cognito:username*. No caso de `AWS_IAM` autorização, o valor do *nome de usuário* é o valor do AWS usuário principal. Se você estiver usando a autorização do IAM com credenciais fornecidas por bancos de identidades do Amazon Cognito, recomendamos utilizar `cognitoIdentityId`.
### Cabeçalhos de solicitação de acesso
AWS AppSync suporta passar cabeçalhos personalizados de clientes e acessá-los em seus resolvedores GraphQL usando. `ctx.request.headers` Em seguida, você pode usar valores de cabeçalho para ações como inserir dados em uma fonte de dados ou até mesmo verificações de autorização. É possível utilizar cabeçalhos de solicitação por meio de `$curl` com uma chave da API na linha de comando conforme mostrado nos exemplos a seguir:
**Exemplo de cabeçalho único**
Digamos que você defina um cabeçalho `custom` com um valor de `nadia` da seguinte forma:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Isso pode ser acessado com `ctx.request.headers.custom`. Por exemplo, ele pode estar no seguinte código para o DynamoDB:
```
"custom": util.dynamodb.toDynamoDB(ctx.request.headers.custom)
```
**Exemplo de vários cabeçalhos**
Você também pode enviar vários cabeçalhos em uma única solicitação e acessá-los no manipulador do resolvedor. Por exemplo, se o cabeçalho `custom` foi definido com dois valores:
```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https:///graphql
```
Em seguida, você pode acessá-los como uma matriz, como `ctx.request.headers.custom[1]`.
**nota**
AWS AppSync não expõe o cabeçalho do cookie em`ctx.request.headers`.
### Acessar o nome de domínio personalizado da solicitação
AWS AppSync suporta a configuração de um domínio personalizado que você pode usar para acessar seu GraphQL e endpoints em tempo real para seu. APIs Ao fazer uma solicitação com um nome de domínio personalizado, você pode obter o nome de domínio usando `ctx.request.domainName`.
Ao usar o nome de domínio padrão do endpoint do GraphQL, o valor será `null`.
### Informações
A seção `info` contém informações sobre a solicitação do GraphQL. Esta seção tem o seguinte formato:
```
type Info = {
fieldName: string;
parentTypeName: string;
variables: any;
selectionSetList: string[];
selectionSetGraphQL: string;
};
```
Cada campo é definido da seguinte forma:
** `fieldName` **
O nome do campo que está sendo resolvido no momento.
** `parentTypeName` **
O nome do tipo pai para o campo que está sendo resolvido no momento.
** `variables` **
Um mapa que contém todas as variáveis que são passadas para a solicitação do GraphQL.
** `selectionSetList` **
Uma representação de lista dos campos no conjunto de seleções do GraphQL. Os campos com alias serão referenciados somente pelo nome do alias, não pelo nome do campo. O exemplo a seguir mostra isso em detalhes.
** `selectionSetGraphQL` **
Uma representação de string do conjunto de seleções, formatada como linguagem de definição de esquema (SDL) do GraphQL. Embora os fragmentos não sejam mesclados no conjunto de seleções, os fragmentos inline são preservados, conforme mostrado no exemplo a seguir.
**nota**
`JSON.stringify` não incluirá `selectionSetGraphQL` e `selectionSetList` na serialização da string. Você deve referenciar essas propriedades diretamente.
Por exemplo, se estiver resolvendo o campo `getPost` da seguinte consulta:
```
query {
getPost(id: $postId) {
postId
title
secondTitle: title
content
author(id: $authorId) {
authorId
name
}
secondAuthor(id: "789") {
authorId
}
... on Post {
inlineFrag: comments: {
id
}
}
... postFrag
}
}
fragment postFrag on Post {
postFrag: comments: {
id
}
}
```
Depois, a variável `ctx.info` completa que está disponível ao processar o manipulador pode ser:
```
{
"fieldName": "getPost",
"parentTypeName": "Query",
"variables": {
"postId": "123",
"authorId": "456"
},
"selectionSetList": [
"postId",
"title",
"secondTitle"
"content",
"author",
"author/authorId",
"author/name",
"secondAuthor",
"secondAuthor/authorId",
"inlineFragComments",
"inlineFragComments/id",
"postFragComments",
"postFragComments/id"
],
"selectionSetGraphQL": "{\n getPost(id: $postId) {\n postId\n title\n secondTitle: title\n content\n author(id: $authorId) {\n authorId\n name\n }\n secondAuthor(id: \"789\") {\n authorId\n }\n ... on Post {\n inlineFrag: comments {\n id\n }\n }\n ... postFrag\n }\n}"
}
```
`selectionSetList` expõe somente campos que pertencem ao tipo atual. Se o tipo atual for uma interface ou união, somente os campos selecionados que pertencem à interface serão expostos. Por exemplo, considerando o seguinte esquema:
```
type Query {
node(id: ID!): Node
}
interface Node {
id: ID
}
type Post implements Node {
id: ID
title: String
author: String
}
type Blog implements Node {
id: ID
title: String
category: String
}
```
E a seguinte consulta:
```
query {
node(id: "post1") {
id
... on Post {
title
}
... on Blog {
title
}
}
}
```
Ao chamar `ctx.info.selectionSetList` na resolução do campo `Query.node`, somente `id` é exposto:
```
"selectionSetList": [
"id"
]
```
# AWS AppSync JavaScript recursos de tempo de execução para resolvedores e funções
O ambiente `APPSYNC_JS` de tempo de execução fornece funcionalidade semelhante à [ECMAScript (ES) versão 6.0](https://262.ecma-international.org/6.0/). Ele suporta um subconjunto dos atributos e fornece alguns métodos adicionais (utilitários) que não fazem parte das especificações ES. Os tópicos a seguir listam todos os atributos de idioma compatíveis:
+ [Recursos de runtime compatíveis](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html): saiba mais sobre os principais atributos, objetos primitivos, objetos e funções integrados e outros elementos compatíveis.
+ [Utilitários integrados](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html): a variável util contém métodos utilitários gerais para ajudar você a trabalhar com dados. A menos que especificado o contrário, todos os utilitários usam o conjunto de caracteres UTF-8.
+ [Módulos integrados](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) - Saiba mais sobre como os módulos integrados podem ajudar a escrever JavaScript resolvedores e funções.
+ [Utilitários de runtime](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html): a biblioteca de runtime fornece utilitários para controlar ou modificar as propriedades de runtime dos seus resolvedores e funções.
+ [Auxiliares de tempo em util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html): a variável util.time contém métodos de data e hora para ajudar a gerar timestamps, converter entre formatos de data e hora e analisar strings de data e hora. A sintaxe dos formatos de data e hora é baseada em [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), que você pode consultar para obter mais documentação.
+ [Auxiliares do DynamoDB em util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html): util.dynamodb contém métodos auxiliares que tornam mais fácil gravar e ler dados no Amazon DynamoDB, como mapeamento e formatação do tipo automático.
+ [Auxiliares HTTP em util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html): o utilitário util.http fornece métodos auxiliares que podem ser usados para gerenciar parâmetros de solicitação HTTP e adicionar cabeçalhos de resposta.
+ [Auxiliares de transformação em util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html): util.transform contém métodos auxiliares que facilitam a execução de operações complexas em fontes de dados.
+ [Auxiliares de string em util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html): util.str contém métodos para ajudar com operações comuns de string.
+ [Extensões](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html): extensions contém um conjunto de métodos para realizar ações adicionais em seus resolvedores.
+ [Auxiliares XML em util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html): util.xml contém métodos para ajudar na conversão de strings XML.
**nota**
Atualmente, essa referência só se aplica à versão **1.0.0** do runtime.
# Atributos compatíveis de runtime
As seções abaixo descrevem o conjunto de atributos compatível com o runtime do APPSYNC\$1JS.
## Atributos principais
Os seguintes atributos principais são compatíveis.
------
#### [ Types ]
Os seguintes tipos são compatíveis:
+ números
+ strings
+ booleanos
+ objects
+ arrays
+ funções
------
#### [ Operators ]
Os operadores são suportados, incluindo:
+ Operadores matemáticos padrão (`+`, `-`, `/`, `%`, `*`, etc.)
+ Operador de coalescência nula (`??`)
+ Encadeamento opcional (`?.`)
+ Operadores bitwise
+ Operador `void` e `typeof`
+ Operadores de distribuição (`...`)
Os operadores a seguir não são aceitos:
+ Operadores unários (`++`, `--` e `~`)
+ Operador `in`
**nota**
Use o operador `Object.hasOwn` para verificar se a propriedade especificada está no objeto especificado.
------
#### [ Statements ]
As seguintes instruções são compatíveis:
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ sintaxe de propagação
Não há suporte para o seguinte:
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**nota**
As exceções são expressões `for-in` e `for-of`, que são suportadas.
+ `throw`
+ `try`
+ `while`
+ Instruções rotuladas
------
#### [ Literals ]
As seguintes [literais do modelo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES 6 são compatíveis:
+ Strings de várias linhas
+ Interpolação de expressão
+ Modelos de aninhamento
------
#### [ Functions ]
A sintaxe da função a seguir também tem suporte:
+ As declarações de função são suportadas.
+ As funções de seta ES 6 são suportadas.
+ A sintaxe de parâmetro rest ES 6 é compatível.
------
#### [ Strict mode ]
As funções operam no modo estrito por padrão, então você não precisa adicionar uma instrução `use_strict` ao seu código de função. Elas não podem ser alteradas.
------
## Objetos primitivos
Os seguintes objetos primitivos de ES e suas funções são compatíveis.
------
#### [ Object ]
Há suporte para os seguintes objetos:
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
As seguintes strings são compatíveis:
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**nota**
Não há suporte para expressões regulares.
No entanto, constructos de expressões regulares estilo Java são compatíveis no parâmetro fornecido. Para obter mais informações, consulte [Padrão](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html).
+ `String.prototype.replaceAll()`
**nota**
Não há suporte para expressões regulares.
No entanto, constructos de expressões regulares estilo Java são compatíveis no parâmetro fornecido. Para obter mais informações, consulte [Padrão](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html).
+ `String.prototype.slice()`
+ `String.prototype.split()`
+ `String.prototype.startsWith()`
+ `String.prototype.toLowerCase()`
+ `String.prototype.toUpperCase()`
+ `String.prototype.trim()`
+ `String.prototype.trimEnd()`
+ `String.prototype.trimStart()`
------
#### [ Number ]
Os seguintes números são compatíveis:
+ `Number.isFinite`
+ `Number.isNaN`
------
## Objetos e funções integrados
As funções e objetos a seguir são compatíveis.
------
#### [ Math ]
As seguintes funções matemáticas são compatíveis:
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
Os seguintes métodos de matriz são compatíveis:
+ `Array.prototype.length`
+ `Array.prototype.concat()`
+ `Array.prototype.fill()`
+ `Array.prototype.flat()`
+ `Array.prototype.indexOf()`
+ `Array.prototype.join()`
+ `Array.prototype.lastIndexOf()`
+ `Array.prototype.pop()`
+ `Array.prototype.push()`
+ `Array.prototype.reverse()`
+ `Array.prototype.shift()`
+ `Array.prototype.slice()`
+ `Array.prototype.sort()`
**nota**
`Array.prototype.sort()` não é compatível com argumentos.
+ `Array.prototype.splice()`
+ `Array.prototype.unshift()`
+ `Array.prototype.forEach()`
+ `Array.prototype.map()`
+ `Array.prototype.flatMap()`
+ `Array.prototype.filter()`
+ `Array.prototype.reduce()`
+ `Array.prototype.reduceRight()`
+ `Array.prototype.find()`
+ `Array.prototype.some()`
+ `Array.prototype.every()`
+ `Array.prototype.findIndex()`
+ `Array.prototype.findLast()`
+ `Array.prototype.findLastIndex()`
+ `delete`
------
#### [ Console ]
O objeto do console está disponível para depuração. Durante a execução da consulta em tempo real, log/error as instruções do console são enviadas para o Amazon CloudWatch Logs (se o registro estiver ativado). Durante a avaliação do código com `evaluateCode`, as instruções de log são retornadas na resposta do comando.
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ Os métodos `apply`, `bind` e `call` não são compatíveis.
+ Os construtores de função não são compatíveis.
+ Não há suporte para passar uma função como argumento.
+ Chamadas de funções recursivas não são compatíveis
------
#### [ JSON ]
Os seguintes métodos JSON são compatíveis:
+ `JSON.parse()`
**nota**
Retornará uma string em branco se a string analisada não for um JSON válido.
+ `JSON.stringify()`
------
#### [ Promises ]
Promessas e processos assíncronos não são compatíveis.
**nota**
O acesso à rede e ao sistema de arquivos não é suportado no `APPSYNC_JS` tempo de execução do AWS AppSync. AWS AppSync lida com todas as operações de E/S com base nas solicitações feitas pelo AWS AppSync resolvedor ou pela AWS AppSync função.
------
## Variáveis globais
As seguintes restrições globais são válidas:
+ `NaN`
+ `Infinity`
+ `undefined`
+ [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html)
+ [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)
+ `runtime`
## Tipos de erro
Não é possível lançar erros com `throw`. Você pode retornar um erro usando a função `util.error()`. Você pode incluir um erro na sua resposta do GraphQL usando a função `util.appendError`.
Para obter mais informações, consulte [Utilitários de erro](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js).
# Utilitários integrados
A variável `util` contém métodos utilitários gerais para ajudar você a trabalhar com dados. A menos que especificado o contrário, todos os utilitários usam o conjunto de caracteres UTF-8.
## Utilitários de codificação
### Lista de utilitários de codificação
**`util.urlEncode(String)`**
Retorna a string de entrada como uma string codificada `application/x-www-form-urlencoded`.
**`util.urlDecode(String)`**
Decodifica uma string codificada `application/x-www-form-urlencoded` de volta ao seu formato não codificado.
**`util.base64Encode(string) : string`**
Codifica a entrada em uma string codificada em base64.
**`util.base64Decode(string) : string`**
Decodifica os dados de uma string codificada em base64.
## Utilitários de geração de ID
### Lista de utilitários de geração de ID
**`util.autoId()`**
Retorna um UUID de 128 bits gerado aleatoriamente.
**`util.autoUlid()`**
Retorna um identificador lexicograficamente classificável universalmente exclusivo (ULID) de 128 bits gerado aleatoriamente.
**`util.autoKsuid()`**
Retorna um identificador exclusivo classificável por K (KSUID) de 128 bits gerado aleatoriamente, codificado em base62, como uma string com comprimento de 27.
## Utilitários de erro
### Lista de utilitários de erro
**`util.error(String, String?, Object?, Object?)`**
Lança um erro personalizado. Isso pode ser usado em modelos de mapeamento da solicitação ou resposta se o modelo detectar um erro com a solicitação ou com o resultado da invocação. Além disso, é possível especificar os campos `errorType`, `data` e `errorInfo`. O valor `data` será adicionado ao bloco `error` correspondente em `errors` na resposta do GraphQL.
`data` será filtrado com base no conjunto de seleção da consulta. O valor `errorInfo` será adicionado ao bloco `error` correspondente em `errors` na resposta do GraphQL.
`errorInfo` **não** será filtrado com base no conjunto de seleção da consulta.
**`util.appendError(String, String?, Object?, Object?)`**
Anexa um erro personalizado no final. Isso pode ser usado em modelos de mapeamento da solicitação ou resposta se o modelo detectar um erro com a solicitação ou com o resultado da invocação. Além disso, é possível especificar os campos `errorType`, `data` e `errorInfo`. Diferente de `util.error(String, String?, Object?, Object?)`, a avaliação do modelo não será interrompida para que os dados possam ser retornados ao chamador. O valor `data` será adicionado ao bloco `error` correspondente em `errors` na resposta do GraphQL.
`data` será filtrado com base no conjunto de seleção da consulta. O valor `errorInfo` será adicionado ao bloco `error` correspondente em `errors` na resposta do GraphQL.
`errorInfo` **não** será filtrado com base no conjunto de seleção da consulta.
## Utilitários de correspondência de tipos e padrões
### Lista de utilitários de correspondência de tipos e padrões
**`util.matches(String, String) : Boolean`**
Retorna verdadeiro se o padrão especificado no primeiro argumento corresponde aos dados fornecidos no segundo argumento. O padrão deve ser uma expressão regular, como `util.matches("a*b", "aaaaab")`. A funcionalidade se baseia em [Padrão](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), que você pode consultar para obter documentação adicional.
**`util.authType()`**
Retorna uma String que descreve o tipo de autenticação múltipla que está sendo usado por uma solicitação, retornando "Autorização do IAM", "Autorização de grupo de usuários", "Autorização do Open ID Connect" ou "Autorização de chave de API".
## Utilitários de comportamento do valor de retorno
### Lista de utilitários de comportamento de valor de retorno
**`util.escapeJavaScript(String)`**
Retorna a string de entrada como uma string JavaScript de escape.
## Utilitários de autorização do resolvedor
### Lista de utilitários de autorização do resolvedor
**`util.unauthorized()`**
Lança `Unauthorized` para o campo a ser resolvido. Use em modelos de mapeamento de solicitação ou resposta para determinar se é preciso ou não permitir que o chamador resolva o campo.
# Módulos integrados
Os módulos fazem parte do `APPSYNC_JS` tempo de execução e fornecem utilitários para ajudar a escrever JavaScript resolvedores e funções. Para amostras e exemplos, consulte o [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub repositório.
## Funções do módulo DynamoDB
As funções do módulo DynamoDB oferecem uma experiência aprimorada ao interagir com fontes de dados do DynamoDB. Você pode fazer solicitações para suas fontes de dados do DynamoDB usando as funções e sem adicionar mapeamento de tipos.
Os módulos são importados usando `@aws-appsync/utils/dynamodb`:
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### Funções
#### Lista de funções
**` get(payload: GetInput): DynamoDBGetItemRequest`**
Consulte [Entradas](#built-in-ddb-modules-inputs) para obter informações sobre GetInput.
Gera um `DynamoDBGetItemRequest` objeto para fazer uma [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)solicitação ao DynamoDB.
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
Gera um `DynamoDBPutItemRequest` objeto para fazer uma [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)solicitação ao DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb'
export function request(ctx) {
return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
```
**`remove(payload): DynamoDBDeleteItemRequest`**
Gera um `DynamoDBDeleteItemRequest` objeto para fazer uma [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)solicitação ao DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
Gera um objeto `DynamoDBScanRequest` para fazer uma solicitação [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) ao DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken } = ctx.args;
return ddb.scan({ limit, nextToken });
}
```
**`sync(payload): DynamoDBSyncRequest`**
Gera um objeto `DynamoDBSyncRequest` para fazer uma solicitação [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). A solicitação só recebe os dados alterados desde a última consulta (atualizações delta). As solicitações só podem ser feitas para fontes de dados versionadas do DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const { limit = 10, nextToken, lastSync } = ctx.args;
return ddb.sync({ limit, nextToken, lastSync });
}
```
**`update(payload): DynamoDBUpdateItemRequest`**
Gera um `DynamoDBUpdateItemRequest` objeto para fazer uma [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)solicitação ao DynamoDB.
### Operações
Os auxiliares de operação permitem que você execute ações específicas em partes dos seus dados durante as atualizações. Para começar, importe `operations` de `@aws-appsync/utils/dynamodb`:
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### Operações de lista
**`add(payload)`**
Uma função auxiliar que adiciona um novo item de atributo ao atualizar o DynamoDB.
**Exemplo**
Para adicionar um endereço (rua, cidade e código postal) a um item existente do DynamoDB usando o valor do ID:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
address: operations.add({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`append (payload)`**
Uma função auxiliar que anexa um payload no final da lista existente no DynamoDB.
**Exemplo**
Para acrescentar amigo IDs (`newFriendIds`) recém-adicionado a uma lista de amigos existente (`friendsIds`) durante uma atualização:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.append(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`decrement (by?)`**
Uma função auxiliar que diminui o valor do atributo existente no item ao atualizar o DynamoDB.
**Exemplo**
Para diminuir o contador de amigos (`friendsCount`) em 10:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.decrement(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`increment (by?)`**
Uma função auxiliar que aumenta o valor do atributo existente no item ao atualizar o DynamoDB.
**Exemplo**
Para aumentar o contador de amigos (`friendsCount`) em 10:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
friendsCount: operations.increment(10),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`prepend (payload)`**
Uma função auxiliar que anexa no início da lista existente no DynamoDB.
**Exemplo**
Para acrescentar amigo IDs (`newFriendIds`) recém-adicionado a uma lista de amigos existente (`friendsIds`) durante uma atualização:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [101, 104, 111];
const updateObj = {
friendsIds: operations.prepend(newFriendIds),
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`replace (payload)`**
Uma função auxiliar que substitui o atributo existente no item ao atualizar um item no DynamoDB. Isso é útil quando você deseja atualizar todo o objeto ou subobjeto no atributo e não apenas as chaves no payload.
**Exemplo**
Para substituir um endereço (rua, cidade e CEP) em um objeto `info`:
```
import { update, operations } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const updateObj = {
info: {
address: operations.replace({
street1: '123 Main St',
city: 'New York',
zip: '10001',
}),
},
};
return update({ key: { id: 1 }, update: updateObj });
}
```
**`updateListItem (payload, index)`**
Uma função auxiliar que substitui um item em uma lista.
**Exemplo**
No escopo do update (`newFriendIds`), este exemplo é usado `updateListItem` para atualizar os valores de ID do segundo item (índice: `1`, novo ID: `102`) e do terceiro item (índice: `2`, novo ID: `112`) em uma lista (`friendsIds`).
```
import { update, operations as ops } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
const newFriendIds = [
ops.updateListItem('102', 1), ops.updateListItem('112', 2)
];
const updateObj = { friendsIds: newFriendIds };
return update({ key: { id: 1 }, update: updateObj });
}
```
### Entradas
#### Lista de entradas
**`Type GetInput`**
```
GetInput: {
consistentRead?: boolean;
key: DynamoDBKey;
}
```
**Declaração de tipo**
+ `consistentRead?: boolean` (opcional)
Um booleano opcional para especificar se você deseja realizar uma leitura altamente consistente com o DynamoDB.
+ `key: DynamoDBKey`(obrigatório)
Um parâmetro obrigatório que especifica a chave do item no DynamoDB. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Declaração de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject | null` (opcional)
Quando você insere um objeto em uma tabela do DynamoDB, pode especificar uma expressão condicional 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.
+ `customPartitionKey?: string` (opcional)
Quando ativado, esse valor de string modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado.
+ `item: Partial`(obrigatório)
O restante dos atributos do item a ser colocado no DynamoDB.
+ `key: DynamoDBKey`(obrigatório)
Um parâmetro obrigatório que especifica a chave do item no DynamoDB em que a inserção será feita. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
+ `populateIndexFields?: boolean` (opcional)
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 *.
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**Declaração de tipo**
+ `query: DynamoDBKeyCondition>`(obrigatório)
Especifica uma condição de chave que descreve os itens a serem consultados. Para um determinado índice, a condição para uma chave de partição deve ser uma igualdade e para a chave de classificação, uma comparação ou `beginsWith` (quando for uma string). Somente tipos de números e strings de caracteres são suportados para chaves de partição e de classificação.
**Exemplo**
Veja o tipo `User` abaixo:
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
A consulta só pode incluir os seguintes campos: `id`, `name` e `age`:
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Declaração de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject` (opcional)
Quando você remove um objeto no DynamoDB, pode especificar uma expressão condicional 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.
**Exemplo**
O exemplo a seguir é uma expressão `DeleteItem` contendo uma condição que permitirá que a operação seja bem-sucedida somente se o proprietário do documento corresponder ao usuário que fez a solicitação.
```
type Task = {
id: string;
title: string;
description: string;
owner: string;
isComplete: boolean;
}
const condition: DynamoDBFilterObject = {
owner: { eq: 'XXXXXXXXXXXXXXXX' },
}
remove({
key: {
id: 'XXXXXXXXXXXXXXXX',
},
condition,
});
```
+ `customPartitionKey?: string` (opcional)
Quando ativado, esse valor `customPartitionKey` modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado.
+ `key: DynamoDBKey`(obrigatório)
Um parâmetro obrigatório que especifica a chave do item no DynamoDB que está sendo removido. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
**Exemplo**
Se `User` tiver apenas a chave de hash com um usuário `id`, a chave ficará assim:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
Se o usuário da tabela tiver a chave de hash (`id`) e a chave de classificação (`name`), a chave ficará assim:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (opcional)
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`.
**`Type ScanInput`**
```
ScanInput: {
consistentRead?: boolean | null;
filter?: DynamoDBFilterObject | null;
index?: string | null;
limit?: number | null;
nextToken?: string | null;
scanIndexForward?: boolean | null;
segment?: number;
select?: DynamoDBSelectAttributes;
totalSegments?: number;
}
```
**Declaração de tipo**
+ `consistentRead?: boolean | null` (opcional)
Um booleano opcional que indica leituras consistentes ao consultar o DynamoDB. O valor padrão é `false`.
+ `filter?: DynamoDBFilterObject | null` (opcional)
Um filtro opcional para aplicar aos resultados depois de recuperá-los da tabela.
+ `index?: string | null` (opcional)
Um nome opcional do índice para digitalizar.
+ `limit?: number | null` (opcional)
O número máximo opcional de resultados a serem retornados.
+ `nextToken?: string | null` (opcional)
O token de paginação opcional para continuar uma consulta anterior. Isso seria obtido de uma consulta anterior.
+ `scanIndexForward?: boolean | null` (opcional)
Um booleano opcional para indicar se a consulta é executada em ordem crescente ou decrescente. Por padrão, esse valor é definido como `true`.
+ `segment?: number` (opcional)
+ `select?: DynamoDBSelectAttributes` (opcional)
Atributos a serem retornados do DynamoDB. Por padrão, o AWS AppSync resolvedor do DynamoDB retorna somente atributos que são projetados no índice. 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`
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 `ProjectionExpression`. Esse valor de retorno é equivalente a especificar `ProjectionExpression` sem especificar nenhum valor para `AttributesToGet`.
+ `totalSegments?: number` (opcional)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**Declaração de tipo**
+ `basePartitionKey?: string` (opcional)
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.
+ `deltaIndexName?: string` (opcional)
O índice usado para a operação Sync. Esse índice é necessário para habilitar uma operação de sincronização em toda a tabela de armazenamento delta quando a tabela usa uma chave de partição personalizada. A operação de sincronização será executada no GSI (criado em `gsi_ds_pk` e `gsi_ds_sk`).
+ `filter?: DynamoDBFilterObject | null` (opcional)
Um filtro opcional para aplicar aos resultados depois de recuperá-los da tabela.
+ `lastSync?: number` (opcional)
O momento, em milésimos de segundos de epoch, no qual a última operação de sincronização bem-sucedida foi iniciada. Se especificado, somente os itens que foram alterados após `lastSync` serão retornados. Este campo deve ser preenchido somente depois de recuperar todas as páginas de uma operação inicial de sincronização. Se omitidos, os resultados da tabela base serão retornados. Caso contrário, os resultados da tabela delta serão retornados.
+ `limit?: number | null` (opcional)
O número máximo opcional de itens a serem avaliados ao mesmo tempo. Se omitido, o limite padrão será definido como `100` itens. O valor máximo para esse campo é de `1000` itens.
+ `nextToken?: string | null` (opcional)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**Declaração de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject` (opcional)
Quando você atualiza um objeto no DynamoDB, pode especificar uma expressão condicional 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.
+ `customPartitionKey?: string` (opcional)
Quando ativado, esse valor `customPartitionKey` modifica o formato dos registros `ds_sk` e `ds_pk` usados pela tabela de sincronização delta quando o versionamento é ativado. Quando ativado, o processamento da entrada `populateIndexFields` também é ativado.
+ `key: DynamoDBKey`(obrigatório)
Um parâmetro obrigatório que especifica a chave do item no DynamoDB que está sendo atualizado. Os itens do DynamoDB podem ter uma única chave de hash ou chaves de hash e de classificação.
+ `populateIndexFields?: boolean` (opcional)
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`.
+ `update: DynamoDBUpdateObject`
Um objeto que especifica os atributos a serem atualizados junto com os novos valores para eles. O objeto de atualização pode ser usado com `add`, `remove`, `replace`, `increment`, `decrement`, `append`, `prepend`, `updateListItem`.
## Funções do módulo do Amazon RDS
As funções do módulo do Amazon RDS oferecem uma experiência aprimorada ao interagir com bancos de dados configurados com a API de dados do Amazon RDS. O módulo é importado usando `@aws-appsync/utils/rds`:
```
import * as rds from '@aws-appsync/utils/rds';
```
As funções também podem ser importadas individualmente. Por exemplo, a importação abaixo usa `sql`:
```
import { sql } from '@aws-appsync/utils/rds';
```
### Funções
Você pode usar os auxiliares utilitários do módulo AWS AppSync RDS para interagir com seu banco de dados.
#### Select
O utilitário `select` cria uma declaração `SELECT` para consultar o banco de dados relacional.
**Uso básico**
Na forma básica, é possível especificar a tabela que deseja consultar:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
Observe também que é possível especificar o esquema no identificador da tabela:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**Especificar colunas**
É possível especificar colunas com a propriedade `columns`. Se isso não for definido como um valor, o padrão será `*`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
Também é possível especificar a tabela de uma coluna:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**Limites e deslocamentos**:
É possível aplicar `limit` e `offset` à consulta:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// LIMIT :limit
// OFFSET :offset
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
limit: 10,
offset: 40
}));
}
```
**Ordenar por**
É possível classificar os resultados com a propriedade `orderBy`. Forneça uma matriz de objetos especificando a coluna e uma propriedade `dir` opcional:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name" FROM "persons"
// ORDER BY "name", "id" DESC
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
}));
}
```
**Filtros**
É possível criar filtros usando o objeto de condição especial:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}}
}));
}
```
Também é possível combinar filtros:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME and "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: {name: {eq: 'Stephane'}, id: {gt: 10}}
}));
}
```
Também é possível criar declarações `OR`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE "name" = :NAME OR "id" > :ID
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { or: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Também é possível negar uma condição com `not`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
// WHERE NOT ("name" = :NAME AND "id" > :ID)
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name'],
where: { not: [
{ name: { eq: 'Stephane'} },
{ id: { gt: 10 } }
]}
}));
}
```
Também é possível usar os seguintes operadores para comparar valores:
|
|
| Operador | Description | Tipos de valores possíveis |
| --- |--- |--- |
| eq | Equal | número, string, booleano |
| ne | Not equal | número, string, booleano |
| le | Menor ou igual a | número, seqüência |
| lt | Menor que | número, seqüência |
| idade | Maior ou igual a | número, seqüência |
| gt | Maior que | número, seqüência |
| contém | Like | string |
| NÃO contém | Não é como | string |
| Começa com | Começa com o prefixo | string |
| entre | Entre dois valores | número, seqüência |
| O atributo existe | O atributo não é nulo | número, string, booleano |
| size | verifica o comprimento do elemento | string |
#### Inserir
O utilitário `insert` oferece uma maneira simples de inserir itens de linha única no banco de dados com a operação `INSERT`.
**Inserções de item único**
Para inserir um item, especifique a tabela e, depois, transmita o objeto de valores. As chaves do objeto são associadas às colunas da tabela. São inseridos automaticamente caracteres de escape nos nomes das colunas e os valores são enviados ao banco de dados usando o mapa de variáveis:
```
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
return createMySQLStatement(insertStatement)
}
```
**Caso de uso do MySQL**
É possível combinar um `insert` seguido por um `select` para recuperar a linha inserida:
```
import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({ table: 'persons', values });
const selectStatement = select({
table: 'persons',
columns: '*',
where: { id: { eq: values.id } },
limit: 1,
});
// Generates statement:
// INSERT INTO `persons`(`name`)
// VALUES(:NAME)
// and
// SELECT *
// FROM `persons`
// WHERE `id` = :ID
return createMySQLStatement(insertStatement, selectStatement)
}
```
**Caso de uso do Postgres**
Com o Postgres, é possível usar [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html) para obter dados da linha que você inseriu. Ele aceita `*` ou uma matriz de nomes de colunas:
```
import { insert, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: values } = ctx.args;
const insertStatement = insert({
table: 'persons',
values,
returning: '*'
});
// Generates statement:
// INSERT INTO "persons"("name")
// VALUES(:NAME)
// RETURNING *
return createPgStatement(insertStatement)
}
```
#### Atualizar
O utilitário `update` permite atualizar as linhas existentes. É possível usar o objeto de condição para aplicar alterações às colunas especificadas em todas as linhas que atendam à condição. Por exemplo, digamos que temos um esquema que nos permita fazer essa mutação. Queremos atualizar o `name` de `Person` com o valor `id` de `3`, mas somente se os conhecermos (`known_since`) desde o ano `2000`:
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
Nosso resolvedor de atualização é semelhante a:
```
import { update, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id, ...values }, condition } = ctx.args;
const where = {
...condition,
id: { eq: id },
};
const updateStatement = update({
table: 'persons',
values,
where,
returning: ['id', 'name'],
});
// Generates statement:
// UPDATE "persons"
// SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
Podemos adicionar uma verificação à nossa condição para garantir que somente a linha que tem a chave primária `id` igual a `3` seja atualizada. Da mesma forma, para Postgres `inserts`, é possível usar `returning` para exibir os dados modificados.
#### Remover
O utilitário `remove` permite excluir as linhas existentes. É possível usar o objeto de condição em todas as linhas que atendam à condição. Observe que `delete` é uma palavra-chave reservada em JavaScript. `remove`deve ser usado em vez disso:
```
import { remove, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
const { input: { id }, condition } = ctx.args;
const where = { ...condition, id: { eq: id } };
const deleteStatement = remove({
table: 'persons',
where,
returning: ['id', 'name'],
});
// Generates statement:
// DELETE "persons"
// WHERE "id" = :ID
// RETURNING "id", "name"
return createPgStatement(updateStatement)
}
```
### Conversão
Em alguns casos, convém ter maior especificidade sobre o tipo de objeto correto a ser usado na declaração. Você pode usar as dicas de tipo fornecidas para especificar o tipo dos seus parâmetros. AWS AppSync suporta os [mesmos tipos de dicas](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) da API de dados. Você pode converter seus parâmetros usando as `typeHint` funções do AWS AppSync `rds` módulo.
O exemplo a seguir permite enviar uma matriz como um valor que é convertido como um objeto JSON. Usamos o operador `->` para recuperar o elemento `index` `2` na matriz JSON:
```
import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const arr = ctx.args.list_of_ids
const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
return createPgStatement(statement)
}
export function response(ctx) {
return toJsonObject(ctx.result)[0][0].value
}
```
A conversão também é útil ao processar e comparar `DATE`, `TIME` e `TIMESTAMP`:
```
import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const when = ctx.args.when
const statement = select({
table: 'persons',
where: { createdAt : { gt: typeHint.DATETIME(when) } }
})
return createPgStatement(statement)
}
```
Veja outro exemplo de como enviar a data e a hora atuais:
```
import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';
export function request(ctx) {
const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}
```
**Dicas de tipo disponíveis**
+ `typeHint.DATE`: o parâmetro correspondente é enviado como objeto do tipo `DATE` ao banco de dados. O formato aceito é `YYYY-MM-DD`.
+ `typeHint.DECIMAL`: o parâmetro correspondente é enviado como objeto do tipo `DECIMAL` ao banco de dados.
+ `typeHint.JSON`: o parâmetro correspondente é enviado como objeto do tipo `JSON` ao banco de dados.
+ `typeHint.TIME`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `TIME` ao banco de dados. O formato aceito é `HH:MM:SS[.FFF]`.
+ `typeHint.TIMESTAMP`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `TIMESTAMP` ao banco de dados. O formato aceito é `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `typeHint.UUID`: o valor de parâmetro de string correspondente é enviado como objeto do tipo `UUID` ao banco de dados.
# Utilitários Runtime
A biblioteca `runtime` fornece utilitários para controlar ou modificar as propriedades de runtime dos seus resolvedores e funções.
## Lista de utilitários de runtime
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
Invocar essa função interromperá a execução do manipulador, AWS AppSync função ou resolvedor atual (Unit ou Pipeline Resolver), dependendo do contexto atual. O objeto especificado é retornado como resultado.
+ Quando chamado em um manipulador de solicitação de AWS AppSync função, a fonte de dados e o manipulador de resposta são ignorados e o próximo manipulador de solicitação de função (ou o manipulador de resposta do resolvedor de pipeline, se essa for a última função) é chamado. AWS AppSync
+ Quando chamado em um manipulador de solicitações do resolvedor de AWS AppSync pipeline, a execução do pipeline é ignorada e o manipulador de resposta do resolvedor de pipeline é chamado imediatamente.
+ Quando `returnOptions` é fornecido com `skipTo` definido como “END”, a execução do pipeline é ignorada, e o processador da resposta do resolvedor de pipeline é chamado imediatamente.
+ Quando `returnOptions` é fornecido com `skipTo` definido como “NEXT”, a execução da função é ignorada, e o próximo processador de pipeline é chamado.
**Exemplo**
```
import { runtime } from '@aws-appsync/utils'
export function request(ctx) {
runtime.earlyReturn({ hello: 'world' })
// code below is not executed
return ctx.args
}
// never called because request returned early
export function response(ctx) {
return ctx.result
}
```
# Auxiliares de tempo de util.time
A variável `util.time` contém métodos de data e hora para ajudar a gerar timestamps, converter entre formatos de data e hora e analisar strings de data e hora. A sintaxe dos formatos de data e hora é baseada na [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)qual você pode consultar para obter mais documentação.
## Lista de utilitários de tempo
**`util.time.nowISO8601()`**
Retorna uma representação em cadeia de caracteres do UTC no [ISO8601formato](https://en.wikipedia.org/wiki/ISO_8601).
**`util.time.nowEpochSeconds()`**
Retorna o número de segundos desde epoch do 1970-01-01T00:00:00Z até agora.
**`util.time.nowEpochMilliSeconds()`**
Retorna o número de milissegundos desde epoch do 1970-01-01T00:00:00Z até agora.
**`util.time.nowFormatted(String)`**
Retorna uma string do timestamp atual em UTC usando o formato especificado a partir de um tipo de entrada String.
**`util.time.nowFormatted(String, String)`**
Retorna uma string do timestamp atual para um fuso horário usando o formato especificado e o fuso horário a partir de tipos de entrada String.
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
Analisa um carimbo de data e hora passado como uma string com um formato contendo um fuso horário e, em seguida, retorna o carimbo de data e hora como milissegundos desde a época.
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
Analisa um timestamp enviado como uma string junto com um formato e fuso horário e retorna o timestamp como milissegundos desde o epoch.
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
Analisa um ISO8601 carimbo de data/hora passado como uma string e, em seguida, retorna o carimbo de data/hora em milissegundos desde a época.
**`util.time.epochMilliSecondsToSeconds(long)`**
Converte um timestamp em milissegundos epoch em um timestamp em segundos epoch.
**`util.time.epochMilliSecondsToISO8601(long)`**
Converte um timestamp de milissegundos de época em um timestamp. ISO8601
**`util.time.epochMilliSecondsToFormatted(long, String)`**
Converte um timestamp em milissegundos epoch enviado como long em um timestamp formatado de acordo com o formato em UTC.
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
Converte um timestamp em milissegundos epoch enviado como um long em um timestamp formatado de acordo com o formato no fuso horário fornecido.
# Auxiliares do DynamoDB em util.dynamodb
`util.dynamodb` contém os métodos auxiliares que facilitam gravar e ler dados no Amazon DynamoDB, como mapeamento e formatação do tipo automático.
## toDynamoDB
### Lista de utilitários do toDynamoDB
**`util.dynamodb.toDynamoDB(Object)`**
Ferramenta de conversão de objetos gerais do DynamoDB que converte objetos de entrada para a representação adequada do DynamoDB. Ela tem opiniões fortes sobre como representa alguns tipos: por exemplo, usará listas ("L") em vez de conjuntos ("SS", "NS", "BS"). Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
**Exemplo de string**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**Exemplo de número**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**Exemplo de booliano**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**Exemplo de lista**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**Exemplo de mapa**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## Utilitários toString
### Lista de utilitários toString
**`util.dynamodb.toString(String)`**
Converte uma string de entrada para o formato de string do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
Converte uma lista com strings para o formato de conjunto de strings do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## Utilitários toNumber
### Lista de utilitários toNumber
**`util.dynamodb.toNumber(Number)`**
Converte um número para o formato de número do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
Converte uma lista de números para o formato de conjunto de números do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## Utilitários toBinary
### Lista de utilitários toBinary
**`util.dynamodb.toBinary(String)`**
Converte dados binários codificados como uma string em base64 para o formato binário do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
Converte uma lista de dados binários codificados como strings em base64 para o formato de conjunto de binários do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## Utilitários toBoolean
### Lista de utilitários toBoolean
**`util.dynamodb.toBoolean(Boolean)`**
Converte um booliano para o formato booliano adequado do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## Utilitários toNull
### Lista de utilitários toNull
**`util.dynamodb.toNull()`**
Retorna um valor nulo no formato nulo do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## Utilitários toList
### Lista de utilitários toList
**`util.dynamodb.toList(List)`**
Converte uma lista de objetos no formato de lista do DynamoDB. Cada item na lista também é convertido para o formato adequado do DynamoDB. Ela tem opiniões fortes sobre como representa alguns dos objetos aninhados: por exemplo, usará listas ("L") em vez de conjuntos ("SS", "NS", "BS"). Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## Utilitários toMap
### Lista de utilitários toMap
**`util.dynamodb.toMap(Map)`**
Converte um mapa para o formato de mapa do DynamoDB. Cada valor no mapa também é convertido para o formato adequado do DynamoDB. Ela tem opiniões fortes sobre como representa alguns dos objetos aninhados: por exemplo, usará listas ("L") em vez de conjuntos ("SS", "NS", "BS"). Isso retorna um objeto que descreve o valor do atributo do DynamoDB.
```
Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
**`util.dynamodb.toMapValues(Map)`**
Cria uma cópia do mapa onde cada valor foi convertido para o formato adequado do DynamoDB. Ela tem opiniões fortes sobre como representa alguns dos objetos aninhados: por exemplo, usará listas ("L") em vez de conjuntos ("SS", "NS", "BS").
```
Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
```
Observação: isso é um pouco diferente de `util.dynamodb.toMap(Map)`, uma vez que retorna somente o conteúdo do valor do atributo do DynamoDB, mas não todo o valor do atributo em si. Por exemplo, as seguintes instruções são exatamente as mesmas:
```
util.dynamodb.toMapValues(