As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # AWS AppSync JavaScript 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() util.dynamodb.toMap()("M") ``` ## Utilitários S3Object ### Lista de utilitários do S3Object **`util.dynamodb.toS3Object(String key, String bucket, String region)`** Converte a chave, bucket e região na representação de Objeto do S3 do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", region = "baz") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo", \"bucket\" : \"bar", \"region\" : \"baz" } }" } ``` **`util.dynamodb.toS3Object(String key, String bucket, String region, String version)`** Converte a chave, o bucket, a região e a versão opcional na representação de objeto do S3 do DynamoDB. Isso retorna um objeto que descreve o valor do atributo do DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", "baz", "beep") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" } ``` **`util.dynamodb.fromS3ObjectJson(String)`** Aceita o valor de string de um objeto do S3 do DynamoDB e retorna um mapa que contém a chave, o bucket, a região e a versão opcional. ``` Input: util.dynamodb.fromS3ObjectJson({ "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" }) Output: { "key" : "foo", "bucket" : "bar", "region" : "baz", "version" : "beep" } ``` # Auxiliares HTTP em util.http 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. ## Lista de utilitários util.http **`util.http.copyHeaders(headers)`** Copia os cabeçalhos do mapa, exceto os seguintes cabeçalhos HTTP restritos: + transfer-encoding + connection + host + expect + keep-alive + upgrade + proxy-authenticate + proxy-authorization + te + content-length **`util.http.addResponseHeader(String, Object)`** Adiciona um único cabeçalho personalizado com o nome (`String`) e o valor (`Object`) da resposta. As limitações a seguir se aplicam a: + Além da lista de cabeçalhos restritos para `copyHeaders(headers)`, os nomes de cabeçalho não podem corresponder a nenhuma das seguintes opções: + Access-Control-Allow-Credentials + Access-Control-Allow-Origin + Access-Control-Expose-Headers + Access-Control-Max-Age + Access-Control-Allow-Methods + Access-Control-Allow-Headers + Vary + Content-Type + Os nomes de cabeçalho não podem começar com prefixos restritos, como `x-amzn-` ou `x-amz-`. + O tamanho dos cabeçalhos de resposta personalizados não pode exceder 4 KB. Isso inclui nomes e valores de cabeçalho. + Você deve definir cada cabeçalho de resposta uma vez por operação do GraphQL. No entanto, se você definir um cabeçalho personalizado com o mesmo nome várias vezes, a definição mais recente aparecerá na resposta. Todos os cabeçalhos são contabilizados para o limite de tamanho do cabeçalho, independentemente do nome. + Cabeçalhos com um nome `(String)` vazio ou restrito ou um valor `(Object)` nulo serão ignorados e gerarão um erro `ResponseHeaderError` adicionado à saída `errors` da operação. ``` export function request(ctx) { util.http.addResponseHeader('itemsCount', 7) util.http.addResponseHeader('render', ctx.args.render) return {} } ``` **`util.http.addResponseHeaders(Map)`** Adiciona vários cabeçalhos de resposta à resposta do mapa especificado de nomes `(String)` e valores `(Object)`. As mesmas limitações listadas para o método `addResponseHeader(String, Object)` também se aplicam a esse método. ``` export function request(ctx) { const headers = { headerInt: 12, headerString: 'stringValue', headerObject: { field1: 7, field2: 'string' } } util.http.addResponseHeaders(headers) return {} } ``` # Auxiliares de transformação em util.transform `util.transform` contém métodos auxiliares que facilitam a execução de operações complexas em fontes de dados. ## Lista de utilitários auxiliares de transformação **`util.transform.toDynamoDBFilterExpression(filterObject: DynamoDBFilterObject) : string`** Converte uma string de entrada em uma expressão de filtro para o uso com o DynamoDB. Recomendamos o uso `toDynamoDBFilterExpression` com [funções de módulo integradas](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html). **`util.transform.toElasticsearchQueryDSL(object: OpenSearchQueryObject) : string`** Converte a entrada fornecida em sua expressão DSL de OpenSearch consulta equivalente, retornando-a como uma string JSON. **Exemplo de entrada:** ``` util.transform.toElasticsearchQueryDSL({ "upvotes":{ "ne":15, "range":[ 10, 20 ] }, "title":{ "eq":"hihihi", "wildcard":"h*i" } }) ``` **Exemplos de resultado:** ``` { "bool":{ "must":[ { "bool":{ "must":[ { "bool":{ "must_not":{ "term":{ "upvotes":15 } } } }, { "range":{ "upvotes":{ "gte":10, "lte":20 } } } ] } }, { "bool":{ "must":[ { "term":{ "title":"hihihi" } }, { "wildcard":{ "title":"h*i" } } ] } } ] } } ``` Presume-se que o operador padrão seja AND. **`util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter`** Converte um objeto de entrada `Map` em um objeto de expressão `SubscriptionFilter`. O método `util.transform.toSubscriptionFilter` é usado como entrada para a extensão `extensions.setSubscriptionFilter()`. Para obter mais informações, consulte [Extensões](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). Os parâmetros e a declaração de retorno estão listados abaixo: *Parâmetros* + `objFilter`: `SubscriptionFilterObject` Um objeto de entrada `Map` que é convertido no objeto de expressão `SubscriptionFilter`. + `ignoredFields`: `SubscriptionFilterExcludeKeysType` (opcional) Um `List` dos nomes de campo no primeiro objeto que serão ignorados. + `rules`: `SubscriptionFilterRuleObject` (opcional) Um objeto `Map` de entrada com regras rígidas que é incluído quando você está criando o objeto de expressão `SubscriptionFilter`. Essas regras estritas são incluídas no objeto de expressão `SubscriptionFilter` de forma que pelo menos uma das regras seja satisfeita para passar pelo filtro de assinatura. *Resposta* Retorna um `[SubscriptionFilter](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)`. **`util.transform.toSubscriptionFilter(Map, List)`** Converte um objeto de entrada `Map` em um objeto de expressão `SubscriptionFilter`. O método `util.transform.toSubscriptionFilter` é usado como entrada para a extensão `extensions.setSubscriptionFilter()`. Para obter mais informações, consulte [Extensões](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). O primeiro argumento é o objeto de entrada `Map` que é convertido no objeto de expressão `SubscriptionFilter`. O segundo argumento é uma `List` de nomes de campos que são ignorados no primeiro objeto de entrada `Map` durante a criação da estrutura do objeto de expressão `SubscriptionFilter`. **`util.transform.toSubscriptionFilter(Map, List, Map)`** Converte um objeto de entrada `Map` em um objeto de expressão `SubscriptionFilter`. O método `util.transform.toSubscriptionFilter` é usado como entrada para a extensão `extensions.setSubscriptionFilter()`. Para obter mais informações, consulte [Extensões](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). **`util.transform.toDynamoDBConditionExpression(conditionObject)`** Cria uma expressão de condição do DynamoDB. ## Argumentos do filtro de assinatura A tabela a seguir explica como os argumentos dos seguintes utilitários são definidos: + `Util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter` ------ #### [ Argument 1: Map ] O argumento 1 é um objeto `Map` com os seguintes valores-chave: + nomes de campos + "and" + "or" Para nomes de campos como chaves, as condições nas entradas desses campos estão no formato `"operator" : "value"`. O exemplo a seguir mostra como entradas podem ser adicionadas ao `Map`: ``` "field_name" : { "operator1" : value } ## We can have multiple conditions for the same field_name: "field_name" : { "operator1" : value "operator2" : value . . . } ``` Quando um campo contém duas ou mais condições, todas essas condições são consideradas para usar a operação OR. A entrada `Map` também pode ter "and" e "or" como chaves, o que implica que todas as entradas dentro dessas devem ser unidas usando a lógica AND ou OR dependendo da chave. Os valores-chave "and" e "or" esperam uma série de condições. ``` "and" : [ { "field_name1" : { "operator1" : value } }, { "field_name2" : { "operator1" : value } }, . . ]. ``` Observe que você pode aninhar "and" e "or". Ou seja, você pode ter aninhado "and"/"or" em outro bloco "and"/"or". No entanto, isso não funciona em campos simples. ``` "and" : [ { "field_name1" : { "operator" : value } }, { "or" : [ { "field_name2" : { "operator" : value } }, { "field_name3" : { "operator" : value } } ]. ``` O exemplo a seguir mostra uma entrada do *argumento 1* usando `util.transform.toSubscriptionFilter(Map) : Map`. **Entrada(s)** Argumento 1: mapa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 2000 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` **Saída** O resultado é um objeto `Map`: ``` { "filterGroup": [ { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 2: List ] O argumento 2 contém uma `List` de nomes de campos que não devem ser considerados na entrada `Map` (argumento 1) durante a criação da estrutura do objeto de expressão `SubscriptionFilter`. A `List` também pode estar vazia. O exemplo a seguir mostra uma entrada do argumento 1 e argumento 2 usando `util.transform.toSubscriptionFilter(Map, List) : Map`. **Entrada(s)** Argumento 1: mapa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argumento 2: lista: ``` ["percentageUp", "author"] ``` **Saída** O resultado é um objeto `Map`: ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 3: Map ] O argumento 3 é um objeto `Map` que tem nomes de campo como valores-chave (não pode ter "and" ou "or"). Para nomes de campos como chaves, as condições nesses campos são entradas no formato `"operator" : "value"`. Diferentemente do argumento 1, o argumento 3 não pode ter várias condições na mesma chave. Além disso, o argumento 3 não possui uma cláusula "and" ou "or"; portanto, também não há aninhamento envolvido. O argumento 3 representa uma lista de regras estritas, que são adicionadas ao objeto de expressão `SubscriptionFilter` para que **pelo menos uma** dessas condições seja atendida para passar pelo filtro. ``` { "fieldname1": { "operator": value }, "fieldname2": { "operator": value } } . . . ``` O exemplo a seguir mostra as entradas de *argumento 1*, *argumento 2* e *argumento 3* usando `util.transform.toSubscriptionFilter(Map, List, Map) : Map`. **Entrada(s)** Argumento 1: mapa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "lt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argumento 2: lista: ``` ["percentageUp", "author"] ``` Argumento 3: mapa: ``` { "upvotes": { "gte": 250 }, "author": { "eq": "Person1" } } ``` **Saída** O resultado é um objeto `Map`: ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "upvotes", "operator": "gte", "value": 250 } ] }, { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "author", "operator": "eq", "value": "Person1" } ] } ] } ``` ------ # Auxiliares de string em util.str `util.str` contém métodos para ajudar com operações comuns de string. ## Lista de utilitários util.str **`util.str.normalize(String, String)`** Normaliza uma string usando uma das quatro formas de normalização unicode: NFC, NFD, NFKC ou NFKD. O primeiro argumento é a string a ser normalizada. O segundo argumento é “nfc”, “nfd”, “nfkc” ou “nfkd”, especificando o tipo de normalização a ser usado no processo de normalização. # Extensões `extensions` contém um conjunto de métodos para realizar ações adicionais nos seus resolvedores. ## Extensões do cache **`extensions.evictFromApiCache(typeName: string, fieldName: string, keyValuePair: Record) : Object`** Elimina um item do cache do lado do AWS AppSync servidor. O primeiro argumento é o nome do tipo. O segundo argumento é o nome do campo. O terceiro argumento é um objeto contendo itens do par de chave/valor que especificam o valor da chave de armazenamento em cache. Você deve colocar os itens no objeto na mesma ordem das chaves de cache em `cachingKey` do resolvedor em cache. Para obter mais informações sobre armazenamento em cache, consulte [Comportamento de cache](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html#caching-behavior). **Exemplo 1:** Este exemplo remove os itens que foram armazenados em cache para um resolvedor chamado `Query.allClasses` no qual uma chave de cache chamada `context.arguments.semester` foi usada. Quando a mutação é chamada e o resolvedor é executado, se uma entrada for limpa com sucesso, a resposta conterá um valor `apiCacheEntriesDeleted` no objeto de extensões que mostra quantas entradas foram excluídas. ``` import { util, extensions } from '@aws-appsync/utils'; export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.evictFromApiCache('Query', 'allClasses', { 'context.arguments.semester': ctx.args.semester, }); return null; } ``` Essa função funciona **somente** para mutações, não para consultas. ## Extensões de assinatura **`extensions.setSubscriptionFilter(filterJsonObject)`** Define filtros de assinatura aprimorados. Cada evento de notificação de assinatura é avaliado em relação aos filtros de assinatura fornecidos e envia notificações aos clientes se todos os filtros forem avaliados como `true`. O argumento é `filterJsonObject` (Mais informações sobre esse argumento podem ser encontradas abaixo na filterJsonObject seção *Argumento:*). Consulte [Filtragem de assinatura avançada](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html). Você pode usar esse método de extensão somente no manipulador de resposta de um resolvedor de assinatura. Além disso, recomendamos usar `util.transform.toSubscriptionFilter` para criar seu filtro. **`extensions.setSubscriptionInvalidationFilter(filterJsonObject)`** Define os filtros de invalidação da assinatura. Os filtros de assinatura são avaliados em relação à carga de invalidação e, em seguida, invalidam determinada assinatura se os filtros forem avaliados como `true`. O argumento é `filterJsonObject` (Mais informações sobre esse argumento podem ser encontradas abaixo na filterJsonObject seção *Argumento:*). Consulte [Filtragem de assinatura avançada](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html). Você pode usar esse método de extensão somente no manipulador de resposta de um resolvedor de assinatura. Além disso, recomendamos usar `util.transform.toSubscriptionFilter` para criar seu filtro. **`extensions.invalidateSubscriptions(invalidationJsonObject)`** Usado para iniciar uma invalidação de assinatura a partir de uma mutação. O argumento é `invalidationJsonObject` (Mais informações sobre esse argumento podem ser encontradas abaixo na invalidationJsonObject seção *Argumento:*). Essa extensão pode ser usada somente nos modelos de mapeamento de resposta dos resolvedores de mutação. Você só pode usar no máximo cinco chamadas de método `extensions.invalidateSubscriptions()` exclusivas em uma única solicitação. Se você exceder esse limite, receberá um erro do GraphQL. ## Argumento: filterJsonObject O objeto JSON define filtros de assinatura ou de invalidação. É uma série de filtros em um `filterGroup`. Cada filtro é uma coleção de filtros individuais. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 } ] }, { "filters" : [ { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` Cada filtro tem três atributos: + `fieldName` – O campo do esquema GraphQL. + `operator` – O tipo de operador. + `value` – Os valores a serem comparados com o valor `fieldName` da notificação de assinatura. Veja a seguir um exemplo de atribuição desses atributos: ``` { "fieldName" : "severity", "operator" : "le", "value" : context.result.severity } ``` ## Argumento: invalidationJsonObject O `invalidationJsonObject` define o seguinte: + `subscriptionField` – A assinatura do esquema GraphQL a ser invalidada. Uma única assinatura, definida como uma string em `subscriptionField`, é considerada invalidada. + `payload` – Uma lista de pares de valores-chave que é usada como entrada para invalidar assinaturas se o filtro de invalidação for avaliado como `true` em relação aos seus valores. O exemplo a seguir invalida clientes inscritos e conectados usando a assinatura de `onUserDelete` quando o filtro de invalidação definido no resolvedor de assinatura é avaliado como `true` em relação ao valor `payload`. ``` export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.invalidateSubscriptions({ subscriptionField: 'onUserDelete', payload: { group: 'Developer', type: 'Full-Time' }, }); return ctx.result; } ``` # Auxiliares XML em util.xml `util.xml` contém métodos para ajudar na conversão de strings XML. ## Lista de utilitários util.xml **`util.xml.toMap(String) : Object`** Converte uma string XML para um dicionário. **Exemplo 1:** ``` Input: 1 Getting started with GraphQL Output (object): { "posts":{ "post":{ "id":1, "title":"Getting started with GraphQL" } } } ``` **Exemplo 2:** ``` Input: 1 Getting started with GraphQL 2 Getting started with AppSync Output (JavaScript object): { "posts":{ "post":[ { "id":1, "title":"Getting started with GraphQL" }, { "id":2, "title":"Getting started with AppSync" } ] } } ``` **`util.xml.toJsonString(String, Boolean?) : String`** Converte uma string XML para uma string JSON. Isso é semelhante a `toMap`, exceto que a saída é uma string. Isso é útil se quiser converter e retornar diretamente a resposta XML de um objeto HTTP para JSON. Você pode definir um parâmetro booleano opcional para determinar se deseja codificar o JSON em string.