Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# AWS AppSync JavaScript características de tiempo de ejecución para resolutores y funciones
El entorno `APPSYNC_JS` de ejecución proporciona una funcionalidad similar a la [versión 6.0 de ECMAScript (ES)](https://262.ecma-international.org/6.0/). Es compatible con un subconjunto de sus características y proporciona algunos métodos adicionales (utilidades) que no forman parte de las especificaciones de ES. En los siguientes temas se mencionan todas las características de lenguaje admitidas:
+ [Características del tiempo de ejecución compatibles](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html): obtenga más información sobre las características principales compatibles, los objetos primitivos, los objetos y funciones integrados, etc.
+ [Utilidades integradas](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html): la variable util contiene métodos de utilidad generales que ayudan a trabajar con los datos. A menos que se especifique lo contrario, todas las utilidades usan el juego de caracteres UTF-8.
+ [Módulos integrados](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html): obtén más información sobre cómo los módulos integrados pueden ayudar a escribir JavaScript resolutores y funciones.
+ [Utilidades del tiempo de ejecución](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html): la biblioteca del tiempo de ejecución proporciona utilidades para controlar o modificar las propiedades de tiempo de ejecución de sus solucionadores y funciones.
+ [Aplicaciones auxiliares de tiempo en util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html): la variable util.time contiene métodos de fecha y hora útiles para ayudar a generar marcas de tiempo, convertir entre formatos de fecha y hora, y analizar cadenas de fecha y hora. La sintaxis de los formatos de fecha y hora se basa en ella [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html), y puede consultarla para obtener más documentación.
+ [Aplicaciones auxiliares de DynamoDB en util.dynamodb](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html): util.dynanodb contiene métodos auxiliares que facilitan la escritura y la lectura de datos en Amazon DynamoDB, como el mapeo y el formato automáticos de tipos de datos.
+ [Aplicaciones auxiliares de HTTP en util.http](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html): la utilidad util.http proporciona métodos auxiliares que puede utilizar para gestionar parámetros de solicitud HTTP y agregar encabezados de respuesta.
+ [Aplicaciones auxiliares de transformación en util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html): util.transform contiene métodos auxiliares que facilitan las operaciones complejas sobre orígenes de datos.
+ [Aplicaciones auxiliares de cadena en util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html): util.str contiene métodos para ayudar con operaciones de cadena comunes.
+ [Extensiones](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html): extensions contiene un conjunto de métodos para realizar acciones adicionales en sus solucionadores.
+ [Aplicaciones auxiliares de XML en util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html): util.xml contiene métodos para ayudar con la conversión de cadenas XML.
**nota**
Actualmente, esta referencia solo se aplica a la versión ejecutable **1.0.0**.
# Características de la versión ejecutable compatibles
En las siguientes secciones se describe el conjunto de características compatibles de la versión ejecutable APPSYNC\$1JS.
## Características principales
Se admiten las siguientes características principales.
------
#### [ Types ]
Se admiten los siguientes tipos:
+ números
+ cadenas
+ booleanos
+ objetos
+ matrices
+ funciones
------
#### [ Operators ]
Se admiten operadores, entre los que se incluyen:
+ operadores matemáticos estándar (`+`, `-`, `/`, `%`, `*`, etc.)
+ operador de fusión de NULL (`??`)
+ Encadenamiento opcional (`?.`)
+ operadores Bitwise
+ operadores `void` y `typeof`
+ operadores de distribución (`...`)
No se admiten los siguientes operadores:
+ operadores unarios (`++`, `--`, y `~`)
+ operador `in`
**nota**
Utilice el operador `Object.hasOwn` para comprobar si la propiedad especificada está en el objeto especificado.
------
#### [ Statements ]
Se admiten las siguientes instrucciones:
+ `const`
+ `let`
+ `var`
+ `break`
+ `else`
+ `for-in`
+ `for-of`
+ `if`
+ `return`
+ `switch`
+ sintaxis de distribución
No se admiten las siguientes:
+ `catch`
+ `continue`
+ `do-while`
+ `finally`
+ `for(initialization; condition; afterthought)`
**nota**
Las excepciones son las expresiones `for-in` y `for-of`, que son compatibles.
+ `throw`
+ `try`
+ `while`
+ instrucciones etiquetadas
------
#### [ Literals ]
Se admiten los siguientes [literales de plantilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) de ES 6:
+ Cadenas de varias líneas
+ Interpolación de expresiones
+ Plantillas de anidamiento
------
#### [ Functions ]
Se admite la sintaxis de la función siguiente:
+ Se admiten las declaraciones de funciones.
+ Se admiten las funciones de flecha de ES 6.
+ Se admite la sintaxis del parámetro rest de ES 6.
------
#### [ Strict mode ]
Las funciones operan en modo estricto de forma predeterminada, por lo que no necesita agregar una instrucción `use_strict` en su código de función. Esto no se puede cambiar.
------
## Objetos primitivos
Se admiten los siguientes objetos primitivos de ES y sus funciones.
------
#### [ Object ]
Los siguientes objetos son compatibles:
+ `Object.assign()`
+ `Object.entries()`
+ `Object.hasOwn()`
+ `Object.keys()`
+ `Object.values()`
+ `delete`
------
#### [ String ]
Se admiten las siguientes cadenas:
+ `String.prototype.length()`
+ `String.prototype.charAt()`
+ `String.prototype.concat()`
+ `String.prototype.endsWith()`
+ `String.prototype.indexOf()`
+ `String.prototype.lastIndexOf()`
+ `String.raw()`
+ `String.prototype.replace()`
**nota**
No se admiten expresiones regulares.
Sin embargo, en el parámetro proporcionado se admiten constructos de expresiones regulares con estilo Java. Para obtener más información, consulte [Patrón](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html).
+ `String.prototype.replaceAll()`
**nota**
No se admiten expresiones regulares.
Sin embargo, en el parámetro proporcionado se admiten constructos de expresiones regulares con estilo Java. Para obtener más información, consulte [Patrón](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 ]
Se admiten los siguientes números:
+ `Number.isFinite`
+ `Number.isNaN`
------
## Objetos y funciones integrados
Se admiten las siguientes funciones y objetos.
------
#### [ Math ]
Las siguientes funciones matemáticas son compatibles:
+ `Math.random()`
+ `Math.min()`
+ `Math.max()`
+ `Math.round()`
+ `Math.floor()`
+ `Math.ceil()`
------
#### [ Array ]
Se admiten los siguientes métodos de matriz:
+ `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()` no admite 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 ]
El objeto de la consola está disponible para su depuración. Durante la ejecución de la consulta en tiempo real, log/error las instrucciones de la consola se envían a Amazon CloudWatch Logs (si el registro está activado). Durante la evaluación de código con `evaluateCode`, las instrucciones de registro se devuelven en la respuesta del comando.
+ `console.error()`
+ `console.log()`
------
#### [ Function ]
+ No se admiten los métodos `apply`, `bind` y `call`.
+ Los constructores de funciones no son compatibles.
+ No se admite la transferencia de una función como argumento.
+ No se admiten llamadas a funciones recursivas.
------
#### [ JSON ]
Se admiten los siguientes métodos JSON:
+ `JSON.parse()`
**nota**
Devuelve una cadena en blanco si la cadena analizada no es un JSON válido.
+ `JSON.stringify()`
------
#### [ Promises ]
No se admiten promesas ni procesos asíncronos.
**nota**
No se admite el acceso a la red y al sistema de archivos durante el `APPSYNC_JS` tiempo de ejecución AWS AppSync. AWS AppSync gestiona todas las operaciones de E/S en función de las solicitudes realizadas por el AWS AppSync solucionador o la AWS AppSync función.
------
## Globals
Se admiten las siguientes constantes globales:
+ `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 error
No se admite la generación de errores con `throw`. Puede devolver un error mediante la función `util.error()`. Puede incluir un error en su respuesta de GraphQL mediante la función `util.appendError`.
Para obtener más información, consulte la sección sobre [utilidades de error](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js).
# Utilidades integradas
La variable `util` contiene métodos de utilidad generales que ayudan a trabajar con los datos. A menos que se especifique lo contrario, todas las utilidades usan el juego de caracteres UTF-8.
## Utilidades de codificación
### Lista de utilidades de codificación
**`util.urlEncode(String)`**
Devuelve la cadena de entrada como una cadena `application/x-www-form-urlencoded` codificada.
**`util.urlDecode(String)`**
Descodifica una cadena `application/x-www-form-urlencoded` codificada y la devuelve a su forma no codificada.
**`util.base64Encode(string) : string`**
Codifica la entrada en una cadena codificada en base64.
**`util.base64Decode(string) : string`**
Descodifica los datos de una cadena codificada en base64.
## Utilidades de generación de ID
### Lista de utilidades de generación de ID
**`util.autoId()`**
Devuelve un UUID de 128 bits generado de forma aleatoria.
**`util.autoUlid()`**
Devuelve un ULID (identificador ordenable lexicográficamente único y universal) de 128 bits generado de forma aleatoria.
**`util.autoKsuid()`**
Devuelve un KSUID (identificador único ordenable por K) de 128 bits generado de forma aleatoria codificado en base62 como una cadena con una longitud de 27.
## Utilidades de error
### Lista de utilidades de error
**`util.error(String, String?, Object?, Object?)`**
Genera un error personalizado. Se puede utilizar en las plantillas de mapeo de solicitud o de respuesta si la plantilla detecta un error en la solicitud o en el resultado de la invocación. También se pueden especificar los campos `errorType`, `data` y `errorInfo`. El valor de `data` se añadirá al bloque `error` correspondiente dentro de `errors` en la respuesta de GraphQL.
`data` se filtrará en función de la selección de consulta establecida. El valor de `errorInfo` se añadirá al bloque `error` correspondiente dentro de `errors` en la respuesta de GraphQL.
`errorInfo` **no** se filtrará en función de la selección de consulta establecida.
**`util.appendError(String, String?, Object?, Object?)`**
Adjunta un error personalizado. Se puede utilizar en las plantillas de mapeo de solicitud o de respuesta si la plantilla detecta un error en la solicitud o en el resultado de la invocación. También se pueden especificar los campos `errorType`, `data` y `errorInfo`. A diferencia de `util.error(String, String?, Object?, Object?)`, la evaluación de la plantilla no se interrumpirá, de modo podrán devolverse datos al intermediario. El valor de `data` se añadirá al bloque `error` correspondiente dentro de `errors` en la respuesta de GraphQL.
`data` se filtrará en función de la selección de consulta establecida. El valor de `errorInfo` se añadirá al bloque `error` correspondiente dentro de `errors` en la respuesta de GraphQL.
`errorInfo` **no** se filtrará en función de la selección de consulta establecida.
## Utilidades de coincidencia de tipos y patrones
### Lista de utilidades de coincidencia de tipos y patrones
**`util.matches(String, String) : Boolean`**
Devuelve un valor true si el patrón especificado en el primer argumento coincide con los datos proporcionados en el segundo argumento. El patrón tiene que ser una expresión regular, por ejemplo `util.matches("a*b", "aaaaab")`. La funcionalidad se basa en [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html), que puede consultar para obtener más información.
**`util.authType()`**
Devuelve una cadena que describe el tipo de autenticación múltiple que utiliza una solicitud y devuelve "Autorización de IAM", "Autorización del grupo de usuarios", "Autorización de Open ID Connect" o "Autorización de la clave de API".
## Utilidades de comportamiento del valor devuelto
### Lista de utilidades de comportamiento del valor devuelto
**`util.escapeJavaScript(String)`**
Devuelve la cadena de entrada como cadena de JavaScript escape.
## Utilidades de autorización del solucionador
### Lista de utilidades de autorización del solucionador
**`util.unauthorized()`**
Genera el código `Unauthorized` para el campo que se está resolviendo. Utilícela en las plantillas de mapeo de solicitudes o de respuestas para determinar si se debe permitir al intermediario que resuelva el campo.
# Módulos integrados
Los módulos son parte del `APPSYNC_JS` tiempo de ejecución y proporcionan utilidades para ayudar a escribir JavaScript resoluciones y funciones. Para ver ejemplos y ejemplos, consulta el [aws-appsync-resolver-samples](https://github.com/aws-samples/aws-appsync-resolver-samples) GitHub repositorio.
## Funciones del módulo de DynamoDB
Las funciones del módulo de DynamoDB proporcionan una experiencia mejorada al interactuar con los orígenes de datos de DynamoDB. Puede realizar solicitudes a sus orígenes de datos de DynamoDB mediante las funciones y sin añadir asignación de tipos.
Los módulos se importan mediante `@aws-appsync/utils/dynamodb`:
```
// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';
```
### Funciones
#### Lista de funciones
**` get(payload: GetInput): DynamoDBGetItemRequest`**
Consulte [Entradas](#built-in-ddb-modules-inputs) para obtener información acerca de GetInput.
Genera un `DynamoDBGetItemRequest` objeto para realizar una [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)solicitud a DynamoDB.
```
import { get } from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return get({ key: { id: ctx.args.id } });
}
```
**`put(payload): DynamoDBPutItemRequest`**
Genera un `DynamoDBPutItemRequest` objeto para realizar una [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)solicitud a 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`**
Genera un `DynamoDBDeleteItemRequest` objeto para realizar una [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-deleteitem)solicitud a DynamoDB.
```
import * as ddb from '@aws-appsync/utils/dynamodb';
export function request(ctx) {
return ddb.remove({ key: { id: ctx.args.id } });
}
```
**`scan(payload): DynamoDBScanRequest`**
Genera un objeto `DynamoDBScanRequest` para realizar una solicitud [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) a 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`**
Genera un objeto `DynamoDBSyncRequest` para realizar una solicitud [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). La solicitud solo recibe los datos modificados desde la última consulta (actualizaciones delta). Las solicitudes solo se pueden realizar a orígenes de datos de DynamoDB con control de versiones.
```
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`**
Genera un `DynamoDBUpdateItemRequest` objeto para realizar una [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)solicitud a DynamoDB.
### Operaciones
Las aplicaciones auxiliares de operación permiten realizar acciones específicas en partes de sus datos durante las actualizaciones. Para empezar, importe `operations` desde `@aws-appsync/utils/dynamodb`:
```
// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
```
#### Lista de operaciones
**`add(payload)`**
Función auxiliar que añade un nuevo elemento de atributo al actualizar DynamoDB.
**Ejemplo**
Para añadir una dirección (calle, ciudad y código postal) a un elemento de DynamoDB existente mediante el valor de 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)`**
Función auxiliar que añade una carga a la lista existente en DynamoDB.
**Ejemplo**
Para añadir un amigo IDs (`newFriendIds`) recién agregado a una lista de amigos existente (`friendsIds`) durante una actualización:
```
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?)`**
Función auxiliar que reduce el valor del atributo existente en el elemento al actualizar DynamoDB.
**Ejemplo**
Para reducir un contador de amigos (`friendsCount`) en 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?)`**
Función auxiliar que incrementa el valor del atributo existente en el elemento al actualizar DynamoDB.
**Ejemplo**
Para incrementar un contador de amigos (`friendsCount`) en 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)`**
Función auxiliar que se antepone a la lista existente en DynamoDB.
**Ejemplo**
Para añadir un amigo IDs (`newFriendIds`) recién añadido a una lista de amigos existente (`friendsIds`) durante una actualización:
```
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)`**
Función auxiliar que sustituye un atributo existente al actualizar un elemento en DynamoDB. Esto resulta útil cuando se desea actualizar todo el objeto o subobjeto en el atributo y no solo las claves en la carga.
**Ejemplo**
Para sustituir una dirección (calle, ciudad y código postal) en un 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)`**
Función auxiliar que sustituye un elemento en una lista.
**Ejemplo**
En el ámbito de la actualización (`newFriendIds`), en este ejemplo se utiliza `updateListItem` para actualizar los valores de ID del segundo elemento (índice: `1`, nuevo ID: `102`) y del tercer elemento (índice: `2`, nuevo ID: `112`) en una 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;
}
```
**Declaración de tipo**
+ `consistentRead?: boolean` (opcional)
Valor booleano opcional para especificar si desea realizar una lectura altamente coherente con DynamoDB.
+ `key: DynamoDBKey` (obligatorio)
Parámetro obligatorio que especifica la clave del elemento en DynamoDB. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.
**`Type PutInput`**
```
PutInput: {
_version?: number;
condition?: DynamoDBFilterObject | null;
customPartitionKey?: string;
item: Partial;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Declaración de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject | null` (opcional)
Al colocar un objeto en una tabla de DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.
+ `customPartitionKey?: string` (opcional)
Cuando se habilita, este valor de cadena modifica el formato de los registros `ds_sk` y `ds_pk` que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`.
+ `item: Partial` (obligatorio)
El resto de los atributos del elemento que deben incluirse en DynamoDB.
+ `key: DynamoDBKey` (obligatorio)
Parámetro obligatorio que especifica la clave del elemento en DynamoDB donde se realizará la operación put. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.
+ `populateIndexFields?: boolean` (opcional)
Valor booleano que, cuando se habilita junto con la `customPartitionKey`, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas `gsi_ds_pk` y `gsi_ds_sk`. Para obtener más información, consulte el artículo sobre [detección de conflictos y sincronización](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) en la *Guía para desarrolladores de AWS AppSync *.
**`Type QueryInput`**
```
QueryInput: ScanInput & {
query: DynamoDBKeyCondition>;
}
```
**Declaración de tipo**
+ `query: DynamoDBKeyCondition>` (obligatorio)
Especifica una condición clave que describe los elementos que se van a consultar. Para un índice determinado, la condición de una clave de partición debe ser una igualdad y la clave de ordenación una comparación o un elemento `beginsWith` (cuando es una cadena). Solo se admiten los tipos Number y String para las claves de partición y ordenación.
**Ejemplo**
Tome el tipo `User` a continuación:
```
type User = {
id: string;
name: string;
age: number;
isVerified: boolean;
friendsIds: string[]
}
```
La consulta solo puede incluir los campos siguientes: `id`, `name` y `age`:
```
const query: QueryInput = {
name: { eq: 'John' },
age: { gt: 20 },
}
```
**`Type RemoveInput`**
```
RemoveInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
}
```
**Declaración de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject` (opcional)
Al quitar un objeto en DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.
**Ejemplo**
El siguiente ejemplo es una expresión `DeleteItem` que contiene una condición que permite que la operación se realice correctamente solo si el propietario del documento coincide con el usuario que realiza la solicitud.
```
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)
Cuando se habilita, el valor `customPartitionKey` modifica el formato de los registros `ds_sk` y `ds_pk` que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`.
+ `key: DynamoDBKey` (obligatorio)
Parámetro obligatorio que especifica la clave del elemento de DynamoDB que se va a quitar. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.
**Ejemplo**
Si un `User` solo tiene la clave hash con un `id` de usuario, la clave tendría el siguiente aspecto:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
}
const key: DynamoDBKey = {
id: 1,
}
```
Si el usuario de la tabla tiene una clave hash (`id`) y una clave de ordenación (`name`), la clave tendría el siguiente aspecto:
```
type User = {
id: number
name: string
age: number
isVerified: boolean
friendsIds: string[]
}
const key: DynamoDBKey = {
id: 1,
name: 'XXXXXXXXXX',
}
```
+ `populateIndexFields?: boolean` (opcional)
Valor booleano que, cuando se habilita junto con la `customPartitionKey`, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas `gsi_ds_pk` y `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;
}
```
**Declaración de tipo**
+ `consistentRead?: boolean | null` (opcional)
Valor booleano opcional para indicar lecturas coherentes al consultar DynamoDB. El valor predeterminado es `false`.
+ `filter?: DynamoDBFilterObject | null` (opcional)
Filtro opcional para aplicar a los resultados después de recuperarlos de la tabla.
+ `index?: string | null` (opcional)
Nombre opcional del índice a examinar.
+ `limit?: number | null` (opcional)
Número máximo opcional de resultados a devolver.
+ `nextToken?: string | null` (opcional)
Token de paginación opcional para continuar una consulta anterior. Se debe obtener de una consulta anterior.
+ `scanIndexForward?: boolean | null` (opcional)
Valor booleano opcional para indicar si la consulta se realiza en orden ascendente o descendente. De forma predeterminada, este valor se establece en `true`.
+ `segment?: number` (opcional)
+ `select?: DynamoDBSelectAttributes` (opcional)
Atributos que se devolverán de DynamoDB. De forma predeterminada, el solucionador de AWS AppSync DynamoDB solo devuelve los atributos que se proyectan en el índice. Los valores admitidos son:
+ `ALL_ATTRIBUTES`
Devuelve todos los atributos de elementos de la tabla o el índice especificados. Si consulta un índice secundario local, DynamoDB recupera todo el elemento de la tabla principal para cada elemento coincidente en el índice. Si el índice está configurado para proyectar todos los atributos de los elementos, todos los datos se pueden obtener del índice secundario local y no es necesario efectuar una recuperación.
+ `ALL_PROJECTED_ATTRIBUTES`
Devuelve todos los atributos que se han proyectado en el índice. Si el índice está configurado para proyectar todos los atributos, este valor de retorno equivale a especificar `ALL_ATTRIBUTES`.
+ `SPECIFIC_ATTRIBUTES`
Devuelve solo los atributos que aparecen en `ProjectionExpression`. Este valor devuelto equivale a especificar `ProjectionExpression` sin especificar ningún valor para `AttributesToGet`.
+ `totalSegments?: number` (opcional)
**`Type DynamoDBSyncInput`**
```
DynamoDBSyncInput: {
basePartitionKey?: string;
deltaIndexName?: string;
filter?: DynamoDBFilterObject | null;
lastSync?: number;
limit?: number | null;
nextToken?: string | null;
}
```
**Declaración de tipo**
+ `basePartitionKey?: string` (opcional)
Clave de partición de la tabla base que se utilizará al realizar una operación Sync. Este campo permite realizar una operación Sync cuando la tabla utiliza una clave de partición personalizada.
+ `deltaIndexName?: string` (opcional)
Índice utilizado para la operación Sync. Este índice es necesario para habilitar una operación Sync en toda la tabla de almacenamiento Delta cuando la tabla utiliza una clave de partición personalizada. La operación Sync se realizará en el GSI (creado en `gsi_ds_pk` y `gsi_ds_sk`).
+ `filter?: DynamoDBFilterObject | null` (opcional)
Filtro opcional para aplicar a los resultados después de recuperarlos de la tabla.
+ `lastSync?: number` (opcional)
Momento, en milisegundos transcurridos desde la fecha de inicio, en el que comenzó la última operación Sync que se ha realizado correctamente. Si se especifica, solo se devuelven los elementos que han cambiado después de `lastSync`. Este campo solo debe rellenarse después de haber recuperado todas las páginas de una operación Sync inicial. Si se omite, se devolverán los resultados de la tabla base. De lo contrario, se devolverán los resultados de la tabla Delta.
+ `limit?: number | null` (opcional)
Número máximo opcional de elementos que se evalúan en una sola vez. Si se omite, el límite predeterminado se establecerá en `100` elementos. El valor máximo de este campo son `1000` elementos.
+ `nextToken?: string | null` (opcional)
**`Type DynamoDBUpdateInput`**
```
DynamoDBUpdateInput: {
_version?: number;
condition?: DynamoDBFilterObject;
customPartitionKey?: string;
key: DynamoDBKey;
populateIndexFields?: boolean;
update: DynamoDBUpdateObject;
}
```
**Declaración de tipo**
+ `_version?: number` (opcional)
+ `condition?: DynamoDBFilterObject` (opcional)
Al actualizar un objeto en DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.
+ `customPartitionKey?: string` (opcional)
Cuando se habilita, el valor `customPartitionKey` modifica el formato de los registros `ds_sk` y `ds_pk` que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`.
+ `key: DynamoDBKey` (obligatorio)
Parámetro obligatorio que especifica la clave del elemento de DynamoDB que se actualiza. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.
+ `populateIndexFields?: boolean` (opcional)
Valor booleano que, cuando se habilita junto con la `customPartitionKey`, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas `gsi_ds_pk` y `gsi_ds_sk`.
+ `update: DynamoDBUpdateObject`
Objeto que especifica los atributos que se van a actualizar junto con sus nuevos valores. El objeto de actualización se puede utilizar con `add`, `remove`, `replace`, `increment`, `decrement`, `append`, `prepend` y `updateListItem`.
## Funciones del módulo Amazon RDS
Las funciones del módulo Amazon RDS ofrecen una experiencia mejorada al interactuar con bases de datos configuradas con la API de datos de Amazon RDS. El módulo se importa mediante `@aws-appsync/utils/rds`:
```
import * as rds from '@aws-appsync/utils/rds';
```
Las funciones también se pueden importar de forma individual. Por ejemplo, la importación siguiente utiliza `sql`:
```
import { sql } from '@aws-appsync/utils/rds';
```
### Funciones
Puede utilizar las utilidades auxiliares del módulo AWS AppSync RDS para interactuar con la base de datos.
#### Select
La utilidad `select` crea una instrucción `SELECT` para consultar la base de datos relacional.
**Uso básico**
En su forma básica, puede especificar la tabla que desea consultar:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// "SELECT * FROM "persons"
return createPgStatement(select({table: 'persons'}));
}
```
Tenga en cuenta que también puede especificar el esquema en el identificador de la tabla:
```
import { select, createPgStatement } from '@aws-appsync/utils/rds';
export function request(ctx) {
// Generates statement:
// SELECT * FROM "private"."persons"
return createPgStatement(select({table: 'private.persons'}));
}
```
**Especificación de columnas**
Puede especificar columnas con la propiedad `columns`. Si no se establece en un valor, el valor predeterminado es `*`:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'name']
}));
}
```
También puede especificar la tabla de una columna:
```
export function request(ctx) {
// Generates statement:
// SELECT "id", "persons"."name"
// FROM "persons"
return createPgStatement(select({
table: 'persons',
columns: ['id', 'persons.name']
}));
}
```
**Límites y desplazamientos**
Puede aplicar `limit` y `offset` a la 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**
Puede ordenar los resultados con la propiedad `orderBy`. Proporcione una matriz de objetos especificando la columna y una propiedad `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**
Puede crear filtros con el objeto de condición 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'}}
}));
}
```
También puede 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}}
}));
}
```
También puede crear instrucciones `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 } }
]}
}));
}
```
También puede negar una condición con `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 } }
]}
}));
}
```
También puede utilizar los siguientes operadores para comparar valores:
|
|
| Operador | Description (Descripción) | Tipos de valor posibles |
| --- |--- |--- |
| eq | Igualdad | número, cadena, booleano |
| ne | Desigualdad | número, cadena, booleano |
| una mentira | Menor que o igual a | número, cadena |
| lt | Menor que | número, cadena |
| edad | Mayor que o igual a | número, cadena |
| gt | Mayor que | número, cadena |
| contains | Como | cadena |
| no contiene | No como | cadena |
| Empieza con | Empieza con el prefijo | cadena |
| entre | Entre dos valores | número, cadena |
| El atributo existe | El atributo no es nulo | número, cadena, booleano |
| tamaño | comprueba la longitud del elemento | cadena |
#### Inserción
La utilidad `insert` ofrece una forma sencilla de insertar elementos de una sola fila en la base de datos con la operación `INSERT`.
**Inserciones de un solo elemento**
Para insertar un elemento, especifique la tabla y, a continuación, transfiera su objeto de valores. Las claves de objetos se asignan a las columnas de la tabla. Los nombres de las columnas se escapan automáticamente y los valores se envían a la base de datos mediante el mapa de variables:
```
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 de MySQL**
Puede combinar un `insert` seguido de un `select` para recuperar la fila insertada:
```
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 de Postgres**
Con Postgres, puede usar [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html) para obtener datos de la fila que insertó. Acepta `*` o una matriz de nombres de columna:
```
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)
}
```
#### Actualización
La utilidad `update` permite actualizar las filas existentes. Puede utilizar el objeto de condición para aplicar cambios a las columnas especificadas en todas las filas que cumplan la condición. Por ejemplo, supongamos que tenemos un esquema que nos permite realizar esta mutación. Queremos actualizar el `name` de `Person` con el valor `id` de `3`, pero solo si los conocemos (`known_since`) desde el año `2000`:
```
mutation Update {
updatePerson(
input: {id: 3, name: "Jon"},
condition: {known_since: {ge: "2000"}}
) {
id
name
}
}
```
Nuestro solucionador de actualización tendrá este aspecto:
```
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 añadir una comprobación a nuestra condición para asegurarnos de que solo se actualice la fila en la que la clave principal `3` sea igual a `id`. Del mismo modo, en el caso de `inserts` de Postgres, se puede utilizar `returning` para devolver los datos modificados.
#### Quitar
La utilidad `remove` permite eliminar las filas existentes. Puede utilizar el objeto de condición en todas las filas que cumplan la condición. Tenga en cuenta que `delete` es una palabra clave reservada en JavaScript. `remove`debería usarse en su lugar:
```
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)
}
```
### Conversión
En algunos casos, es posible que desee más especificidad sobre el tipo de objeto correcto para usar en su instrucción. Puede utilizar las sugerencias de tipo proporcionadas para especificar el tipo de parámetros. AWS AppSync admite las [mismas sugerencias de tipo](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) que la API de datos. Puede convertir sus parámetros mediante las `typeHint` funciones del AWS AppSync `rds` módulo.
En el siguiente ejemplo puede enviar una matriz como un valor que se convierte en un objeto JSON. Usamos el operador `->` para recuperar el elemento en el `index` `2` en la 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
}
```
La conversión también resulta útil al manipular y comparar `DATE`, `TIME` y `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)
}
```
Aquí se muestra otro ejemplo de cómo puede enviar la fecha y hora actuales:
```
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)}`)
}
```
**Sugerencias de tipos disponibles**
+ `typeHint.DATE`: el parámetro correspondiente se envía como un objeto de tipo `DATE` a la base de datos. El formato aceptado es `YYYY-MM-DD`.
+ `typeHint.DECIMAL`: el parámetro correspondiente se envía como un objeto de tipo `DECIMAL` a la base de datos.
+ `typeHint.JSON`: el parámetro correspondiente se envía como un objeto de tipo `JSON` a la base de datos.
+ `typeHint.TIME`: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo `TIME` a la base de datos. El formato aceptado es `HH:MM:SS[.FFF]`.
+ `typeHint.TIMESTAMP`: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo `TIMESTAMP` a la base de datos. El formato aceptado es `YYYY-MM-DD HH:MM:SS[.FFF]`.
+ `typeHint.UUID`: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo `UUID` a la base de datos.
# Utilidades de tiempo de ejecución
La biblioteca de `runtime` proporciona utilidades para controlar o modificar las propiedades de tiempo de ejecución de sus solucionadores y funciones.
## Lista de utilidades de tiempo de ejecución
**`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`**
Al invocar esta función, se detendrá la ejecución del controlador, AWS AppSync función o resolución actual (Unit o Pipeline Resolver) según el contexto actual. El objeto especificado se devuelve como resultado.
+ Cuando se llama en un controlador de solicitudes de AWS AppSync función, se omiten la fuente de datos y el controlador de respuestas y se llama al siguiente controlador de solicitudes de función (o al controlador de respuestas del solucionador de canalización si esta fue la última función). AWS AppSync
+ Cuando se llama a un controlador de solicitudes del solucionador de AWS AppSync canalizaciones, se omite la ejecución de la canalización y se llama inmediatamente al controlador de respuesta del solucionador de canalizaciones.
+ Cuando `returnOptions` se suministra con el valor `skipTo` establecido en “FINAL”, se omite la ejecución de la canalización y se llama inmediatamente al controlador de respuestas del solucionador de canalización.
+ Cuando `returnOptions` se suministra con el valor `skipTo` establecido en “SIGUIENTE”, se omite la ejecución de la función y se llama al siguiente controlador de canalización.
**Ejemplo**
```
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
}
```
# Aplicaciones auxiliares de tiempo en util.time
La variable `util.time` contiene métodos de fecha y hora útiles para ayudar a generar marcas de tiempo, convertir entre formatos de fecha y hora y analizar cadenas de fecha y hora. Puedes consultar la sintaxis de los formatos de fecha y hora para obtener más documentación. [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
## Lista de utilidades de tiempo
**`util.time.nowISO8601()`**
[Devuelve una representación en cadena de UTC en ISO8601 formato String.](https://en.wikipedia.org/wiki/ISO_8601)
**`util.time.nowEpochSeconds()`**
Devuelve el número de segundos desde la fecha de inicio de 1970-01-01T00:00:00Z hasta ahora.
**`util.time.nowEpochMilliSeconds()`**
Devuelve el número de milisegundos desde la fecha de inicio de 1970-01-01T00:00:00Z hasta ahora.
**`util.time.nowFormatted(String)`**
Devuelve una cadena con la marca de tiempo actual en UTC utilizando el formato especificado en un tipo de entrada String.
**`util.time.nowFormatted(String, String)`**
Devuelve una cadena con la marca de tiempo actual de una zona horaria utilizando el formato y la zona horaria especificados en tipos de entrada String.
**`util.time.parseFormattedToEpochMilliSeconds(String, String)`**
Analiza una marca de tiempo pasada como cadena junto con un formato que contiene una zona horaria y, a continuación, la devuelve como milisegundos transcurridos desde la fecha de inicio.
**`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`**
Analiza una marca de tiempo pasada como cadena junto con un formato y una zona horaria y, a continuación, la devuelve como milisegundos transcurridos desde la fecha de inicio.
**`util.time.parseISO8601ToEpochMilliSeconds(String)`**
Analiza una ISO8601 marca de tiempo pasada como cadena y, a continuación, devuelve la marca de tiempo en milisegundos desde la época.
**`util.time.epochMilliSecondsToSeconds(long)`**
Convierte una marca de tiempo en milisegundos desde la fecha de inicio en una marca de tiempo en segundos de la fecha de inicio.
**`util.time.epochMilliSecondsToISO8601(long)`**
Convierte una marca de tiempo de milisegundos de época en una marca de tiempo. ISO8601
**`util.time.epochMilliSecondsToFormatted(long, String)`**
Convierte una marca de tiempo en milisegundos desde la fecha de inicio, pasada como tipo long, en una marca de tiempo UTC con el formato suministrado.
**`util.time.epochMilliSecondsToFormatted(long, String, String)`**
Convierte una marca de tiempo en milisegundos desde la fecha de inicio, pasada como tipo long, en una marca de tiempo para la zona horaria y con el formato suministrados.
# Aplicaciones auxiliares de DynamoDB en util.dynamodb
`util.dynamodb` contiene métodos auxiliares que facilitan la escritura y la lectura de datos en Amazon DynamoDB, como el mapeo y el formato automáticos de los tipos de datos.
## toDynamoDB
### Lista de utilidades toDynamoDB
**`util.dynamodb.toDynamoDB(Object)`**
Herramienta de conversión general de objetos para DynamoDB que convierte objetos de entrada en la representación de DynamoDB correspondiente. Es algo inflexible en cuanto al modo en que representa algunos tipos: por ejemplo, utiliza listas ("L") en lugar de conjuntos ("SS", "NS" "BS"). Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
**Ejemplo de cadena**
```
Input: util.dynamodb.toDynamoDB("foo")
Output: { "S" : "foo" }
```
**Ejemplo de número**
```
Input: util.dynamodb.toDynamoDB(12345)
Output: { "N" : 12345 }
```
**Ejemplo de booleano**
```
Input: util.dynamodb.toDynamoDB(true)
Output: { "BOOL" : true }
```
**Ejemplo de lista**
```
Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
**Ejemplo de mapa**
```
Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] })
Output: {
"M" : {
"foo" : { "S" : "bar" },
"baz" : { "N" : 1234 },
"beep" : {
"L" : [
{ "S" : "boop" }
]
}
}
}
```
## Utilidades toString
### Lista de utilidades toString
**`util.dynamodb.toString(String)`**
Convierte una cadena de entrada al formato de cadena de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toString("foo")
Output: { "S" : "foo" }
```
**`util.dynamodb.toStringSet(List)`**
Convierte una lista con cadenas al formato de conjunto de cadenas de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ])
Output: { "SS" : [ "foo", "bar", "baz" ] }
```
## Utilidades toNumber
### Lista de utilidades toNumber
**`util.dynamodb.toNumber(Number)`**
Convierte un número al formato de número de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toNumber(12345)
Output: { "N" : 12345 }
```
**`util.dynamodb.toNumberSet(List)`**
Convierte una lista de números al formato de conjunto de números de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ])
Output: { "NS" : [ 1, 23, 4.56 ] }
```
## Utilidades toBinary
### Lista de utilidades toBinary
**`util.dynamodb.toBinary(String)`**
Convierte datos binarios codificados como una cadena en base64 al formato binario de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toBinary("foo")
Output: { "B" : "foo" }
```
**`util.dynamodb.toBinarySet(List)`**
Convierte una lista de datos binarios codificados como cadenas en base64 al formato de conjunto binario de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ])
Output: { "BS" : [ "foo", "bar", "baz" ] }
```
## Utilidades toBoolean
### Lista de utilidades toBoolean
**`util.dynamodb.toBoolean(Boolean)`**
Convierte un valor booleano al formato booleano correspondiente de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toBoolean(true)
Output: { "BOOL" : true }
```
## Utilidades toNull
### Lista de utilidades toNull
**`util.dynamodb.toNull()`**
Devuelve un valor nulo con el formato nulo de DynamoDB. Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toNull()
Output: { "NULL" : null }
```
## Utilidades toList
### Lista de utilidades toList
**`util.dynamodb.toList(List)`**
Convierte una lista de objetos al formato de lista de DynamoDB. Cada elemento de la lista se convierte también al formato correspondiente de DynamoDB. Es algo inflexible en cuanto al modo en que representa algunos objetos anidados: por ejemplo, utiliza listas ("L") en lugar de conjuntos ("SS", "NS" "BS"). Esto devuelve un objeto que describe el valor del atributo de DynamoDB.
```
Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ])
Output: {
"L" : [
{ "S" : "foo" },
{ "N" : 123 },
{
"M" : {
"bar" : { "S" : "baz" }
}
}
]
}
```
## Utilidades toMap
### Lista de utilidades toMap
**`util.dynamodb.toMap(Map)`**
Convierte un mapa al formato de mapa de DynamoDB. Cada valor del mapa se convierte también al formato de DynamoDB correspondiente. Es algo inflexible en cuanto al modo en que representa algunos objetos anidados: por ejemplo, utiliza listas ("L") en lugar de conjuntos ("SS", "NS" "BS"). Esto devuelve un objeto que describe el valor del atributo de 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)`**
Crea una copia del mapa en la que cada valor se convierte al formato correspondiente de DynamoDB. Es algo inflexible en cuanto al modo en que representa algunos objetos anidados: por ejemplo, utiliza listas ("L") en lugar 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" }
]
}
}
```
Esto es ligeramente diferente de `util.dynamodb.toMap(Map)`, ya que solo devuelve el contenido del valor de atributo de DynamoDB y no todo el valor de atributo en sí. Por ejemplo, las siguientes instrucciones son exactamente lo mismo:
```
util.dynamodb.toMapValues(