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 referencia de función de resolución para DynamoDB
La función AWS AppSync DynamoDB le permite utilizar [GraphQL](https://graphql.org) para almacenar y recuperar datos de las tablas de Amazon DynamoDB existentes en su cuenta al mapear una solicitud de GraphQL entrante a una llamada de DynamoDB y, a continuación, volver a asignar la respuesta de DynamoDB a GraphQL. En esta sección se describen los controladores de solicitudes y respuestas para las operaciones de DynamoDB admitidas:
+ [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-getitem.html)- La GetItem solicitud permite indicar a la función de DynamoDB que realice GetItem una solicitud a DynamoDB y permite especificar la clave del elemento en DynamoDB y si se debe utilizar una lectura coherente o no.
+ [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-putitem.html)- El documento de mapeo de PutItem solicitudes le permite indicar a la función de DynamoDB que realice PutItem una solicitud a DynamoDB y le permite especificar la clave del elemento en DynamoDB, todo el contenido del elemento (compuesto por valores de clave y atributo) y las condiciones para que la operación se realice correctamente.
+ [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-updateitem.html)- La UpdateItem solicitud le permite indicar a la función de DynamoDB que realice una UpdateItem solicitud a DynamoDB y le permite especificar la clave del elemento en DynamoDB, una expresión de actualización que describe cómo actualizar el elemento en DynamoDB y las condiciones para que la operación se realice correctamente.
+ [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-deleteitem.html)- La DeleteItem solicitud le permite indicar a la función de DynamoDB que realice una DeleteItem solicitud a DynamoDB y le permite especificar la clave del elemento en DynamoDB y las condiciones para que la operación se realice correctamente.
+ [Query](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-query.html): el objeto de solicitud Query permite indicar al solucionador de DynamoDB que realice una solicitud Query a DynamoDB, así como especificar la expresión clave, el índice que se debe utilizar, los filtros adicionales, el número de elementos que se deben devolver, si se deben utilizar lecturas coherentes, la dirección de la consulta (hacia adelante o hacia atrás) y los tokens de paginación.
+ [Scan](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-scan.html): la solicitud Scan permite indicar a la función de DynamoDB que realice una solicitud Scan a DynamoDB, así como especificar un filtro para excluir resultados, el índice que se debe utilizar, cuántos elementos se deben devolver, si se deben utilizar lecturas coherentes, los tokens de paginación y los escaneos paralelos.
+ [Sync](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-sync.html): el objeto de solicitud Sync permite recuperar todos los resultados de una tabla de DynamoDB y, a continuación, recibir tan solo los datos modificados desde la última consulta (las actualizaciones delta). Únicamente se pueden realizar solicitudes Sync a orígenes de datos con control de versiones de DynamoDB. Puede especificar un filtro para excluir resultados, el número de elementos que se deben devolver, los tokens de paginación y cuándo se inició la última operación Sync.
+ [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-get-item.html)- El objeto de BatchGetItem solicitud permite indicar a la función de DynamoDB que realice una BatchGetItem solicitud a DynamoDB para recuperar varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar tanto los nombres de las tablas de las que se van a recuperar los elementos como las claves de los elementos que se van a recuperar de cada tabla.
+ [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-delete-item.html)- El objeto de BatchDeleteItem solicitud permite indicar a la función de DynamoDB que BatchWriteItem solicite a DynamoDB la eliminación de varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar tanto los nombres de las tablas de las que se van a eliminar los elementos como las claves de los elementos que se van a eliminar de cada tabla.
+ [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-batch-put-item.html)- El objeto de BatchPutItem solicitud permite indicar a la función de DynamoDB que BatchWriteItem solicite a DynamoDB que coloque varios elementos, posiblemente en varias tablas. Para este objeto de solicitud, debe especificar tanto los nombres de las tablas en las que se van a colocar los elementos como los elementos completos que se van a colocar en cada tabla.
+ [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-get-items.html)- El objeto de TransactGetItems solicitud le permite indicar a la función de DynamoDB que realice una TransactGetItems solicitud a DynamoDB para recuperar varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar tanto el nombre de la tabla de cada elemento de solicitud de la que se van a recuperar los elementos como la clave de cada elemento de solicitud que se va a recuperar de cada tabla.
+ [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- El objeto de TransactWriteItems solicitud permite indicar a la función de DynamoDB que realice una TransactWriteItems solicitud a DynamoDB para escribir varios elementos, posiblemente en varias tablas. Para este objeto de solicitud, debe especificar tanto el nombre de la tabla de destino de cada elemento de solicitud, la operación de cada elemento de solicitud que se va a realizar y la clave de cada elemento de solicitud que se va a escribir.
+ [Sistema de tipos (mapeo de solicitudes)](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-typed-values-request.html): obtenga más información sobre cómo se integra la escritura de DynamoDB en las solicitudes. AWS AppSync
+ [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-typed-values-responses.html): obtenga más información sobre cómo los tipos de DynamoDB se convierten automáticamente a GraphQL o JSON en una carga útil de respuesta.
+ [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-filter.html): obtenga más información sobre los filtros para las operaciones Query y Scan.
+ [Expresiones de condición](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-condition-expressions.html): obtenga más información sobre las expresiones de condición para las PutItem operaciones y UpdateItem DeleteItem las mismas.
+ [Expresiones de condiciones de transacción](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions.html): obtenga más información sobre las expresiones de condiciones para TransactWriteItems las operaciones.
+ [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-projections.html): obtenga más información sobre cómo especificar los atributos en las operaciones de lectura.
# GetItem
La `GetItem` solicitud le permite indicar a la función de AWS AppSync DynamoDB que realice una `GetItem` solicitud a DynamoDB y le permite especificar:
+ La clave del elemento de DynamoDB
+ Si se utiliza una lectura consistente o no.
La solicitud `GetItem` tiene la estructura siguiente:
```
type DynamoDBGetItem = {
operation: 'GetItem';
key: { [key: string]: any };
consistentRead?: ConsistentRead;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Los campos se definen de la siguiente manera:
## GetItem campos
### GetItem lista de campos
**`operation`**
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `GetItem`, este valor se debe establecer en `GetItem`. Este valor es obligatorio.
**`key`**
La clave del elemento de DynamoDB. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
**`consistentRead`**
Indica si se realizará o no una lectura lectura altamente coherente con DynamoDB. Este valor es opcional y de forma predeterminada es `false`.
**`projection`**
Proyección que se utiliza para especificar los atributos que se devolverán de la operación de DynamoDB. Para obtener más información acerca de las proyecciones, consulte la sección [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Este campo es opcional.
El elemento que se devuelve desde DynamoDB se convierte automáticamente a tipos primitivos de GraphQL y JSON, y se encuentra disponible en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obtener más información sobre los JavaScript resolutores, consulte la descripción general de los [JavaScript resolutores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Ejemplo
El siguiente ejemplo es un controlador de solicitudes de función para una consulta de GraphQL `getThing(foo: String!, bar: String!)`:
```
export function request(ctx) {
const {foo, bar} = ctx.args
return {
operation : "GetItem",
key : util.dynamodb.toMapValues({foo, bar}),
consistentRead : true
}
}
```
Para obtener más información sobre la API `GetItem` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).
# PutItem
El documento de mapeo de `PutItem` solicitudes le permite indicar a la función de AWS AppSync DynamoDB que realice `PutItem` una solicitud a DynamoDB y le permite especificar lo siguiente:
+ La clave del elemento de DynamoDB
+ El contenido completo del elemento (compuesto de `key` y `attributeValues`).
+ Condiciones para que la operación se lleve a cabo correctamente.
La solicitud `PutItem` tiene la estructura siguiente:
```
type DynamoDBPutItemRequest = {
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: any};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Los campos se definen de la siguiente manera:
## PutItem campos
### PutItem lista de campos
**`operation`**
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `PutItem`, este valor se debe establecer en `PutItem`. Este valor es obligatorio.
**`key`**
La clave del elemento de DynamoDB. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
**`attributeValues`**
El resto de los atributos del elemento que debe colocarse en DynamoDB. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este campo es opcional.
**`condition`**
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `PutItem` sobrescribe todas las entradas existentes para dicho elemento. Para obtener más información sobre las condiciones, consulte [Expresiones de condición](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). Este valor es opcional.
**`_version`**
Valor numérico que representa la última versión conocida de un elemento. Este valor es opcional. Este campo se utiliza para *detectar conflictos* y solo se admite en orígenes de datos con control de versiones.
**`customPartitionKey`**
Cuando está activado, este valor de cadena modifica el formato `ds_sk` y los `ds_pk` registros que utiliza la tabla de sincronización delta cuando se ha activado el control de versiones (para obtener más información, consulte [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 AWS AppSync desarrolladores*). Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`. Este campo es opcional.
**`populateIndexFields`**
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 *. Este campo es opcional.
El elemento que se escribe en DynamoDB se convierte automáticamente a los tipos primitivos de GraphQL y JSON, y está disponible en el resultado del contexto (`context.result`).
El elemento que se escribe en DynamoDB se convierte automáticamente a los tipos primitivos de GraphQL y JSON, y está disponible en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
[Para obtener más información sobre los JavaScript solucionadores, consulta JavaScript la descripción general de los solucionadores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Ejemplo 1
El siguiente ejemplo es un controlador de solicitudes de función para una mutación de GraphQL `updateThing(foo: String!, bar: String!, name: String!, version: Int!)`.
Si no existe ningún elemento con la clave especificada, dicho elemento se crea. Si ya existe un elemento con la clave especificada, dicho elemento se sobrescribe.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Ejemplo 2
El siguiente ejemplo es un controlador de solicitudes de función para una mutación de GraphQL `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)`.
En este ejemplo se comprueba que el elemento que se encuentra actualmente en DynamoDB tiene el campo `version` establecido en `expectedVersion`.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, name, expectedVersion } = ctx.args;
const values = { name, version: expectedVersion + 1 };
let condition = util.transform.toDynamoDBConditionExpression({
version: { eq: expectedVersion },
});
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ foo, bar }),
attributeValues: util.dynamodb.toMapValues(values),
condition,
};
}
```
Para obtener más información sobre la API `PutItem` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).
# UpdateItem
La `UpdateItem` solicitud le permite indicar a la función de AWS AppSync DynamoDB que realice una `UpdateItem` solicitud a DynamoDB y le permite especificar lo siguiente:
+ La clave del elemento de DynamoDB
+ Una expresión de actualización que describe cómo se actualiza el elemento de DynamoDB
+ Condiciones para que la operación se lleve a cabo correctamente.
La solicitud `UpdateItem` tiene la estructura siguiente:
```
type DynamoDBUpdateItemRequest = {
operation: 'UpdateItem';
key: { [key: string]: any };
update: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Los campos se definen de la siguiente manera:
## UpdateItem campos
### UpdateItem lista de campos
**`operation`**
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `UpdateItem`, este valor se debe establecer en `UpdateItem`. Este valor es obligatorio.
**`key`**
La clave del elemento de DynamoDB. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
**`update`**
La sección `update` permite especificar una expresión de actualización que describe cómo se actualiza el elemento en DynamoDB. Para obtener más información sobre cómo escribir expresiones de actualización, consulte la documentación de [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta sección es obligatoria.
La sección `update` tiene tres componentes:
** `expression` **
La expresión de actualización. Este valor es obligatorio.
** `expressionNames` **
Las sustituciones de los marcadores de posición de *nombre* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre usado en la `expression` y el valor tiene que ser una cadena que corresponda al nombre de atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de marcadores de posición de nombre de atributo de expresión que se usen en la `expression`.
** `expressionValues` **
Las sustituciones de los marcadores de posición de *valor* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la `expression` y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor debe especificarse. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la `expression`.
**`condition`**
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `UpdateItem` actualiza todas las entradas existentes independientemente de su estado actual. Para obtener más información sobre las condiciones, consulte [Expresiones de condición](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). Este valor es opcional.
**`_version`**
Valor numérico que representa la última versión conocida de un elemento. Este valor es opcional. Este campo se utiliza para *detectar conflictos* y solo se admite en orígenes de datos con control de versiones.
**`customPartitionKey`**
*Cuando está activado, este valor de cadena modifica el formato `ds_sk` y los `ds_pk` registros utilizados por la tabla de sincronización delta cuando se ha activado el control de versiones (para obtener más información, consulte [Detección de conflictos y sincronización](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) en la AWS AppSync Guía para desarrolladores).* Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`. Este campo es opcional.
**`populateIndexFields`**
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 *. Este campo es opcional.
El elemento que se actualiza en DynamoDB se convierte automáticamente a los tipos primitivos de GraphQL y JSON, y está disponible en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
[Para obtener más información sobre los JavaScript solucionadores, consulta JavaScript la descripción general de los solucionadores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Ejemplo 1
El siguiente ejemplo es un controlador de solicitudes de función para la mutación de GraphQL `upvote(id: ID!)`.
En este ejemplo, se han incrementado en 1 los campos `upvotes` y `version` de un elemento de DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id } = ctx.args;
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ id }),
update: {
expression: 'ADD #votefield :plusOne, version :plusOne',
expressionNames: { '#votefield': 'upvotes' },
expressionValues: { ':plusOne': { N: 1 } },
},
};
}
```
## Ejemplo 2
El siguiente ejemplo es un controlador de solicitudes de función para una mutación de GraphQL `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)`.
Se trata de un ejemplo complejo que inspecciona los argumentos y genera de manera dinámica la expresión de actualización que solo incluye los argumentos que ha proporcionado el cliente. Por ejemplo, si se omiten `title` y `author`, no se actualizan. Si se especifica un argumento pero su valor es `null`, ese campo se elimina del objeto en DynamoDB. Por último, la operación tiene una condición que comprueba si el elemento que está actualmente en DynamoDB tiene el campo `version` establecido en `expectedVersion`:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { args: { input: { id, ...values } } } = ctx;
const condition = {
id: { attributeExists: true },
version: { eq: values.expectedVersion },
};
values.expectedVersion += 1;
return dynamodbUpdateRequest({ keys: { id }, values, condition });
}
/**
* Helper function to update an item
* @returns an UpdateItem request
*/
function dynamodbUpdateRequest(params) {
const { keys, values, condition: inCondObj } = params;
const sets = [];
const removes = [];
const expressionNames = {};
const expValues = {};
// Iterate through the keys of the values
for (const [key, value] of Object.entries(values)) {
expressionNames[`#${key}`] = key;
if (value) {
sets.push(`#${key} = :${key}`);
expValues[`:${key}`] = value;
} else {
removes.push(`#${key}`);
}
}
let expression = sets.length ? `SET ${sets.join(', ')}` : '';
expression += removes.length ? ` REMOVE ${removes.join(', ')}` : '';
const condition = JSON.parse(
util.transform.toDynamoDBConditionExpression(inCondObj)
);
return {
operation: 'UpdateItem',
key: util.dynamodb.toMapValues(keys),
condition,
update: {
expression,
expressionNames,
expressionValues: util.dynamodb.toMapValues(expValues),
},
};
}
```
Para obtener más información sobre la API `UpdateItem` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).
# DeleteItem
La `DeleteItem` solicitud le permite indicar a la función de AWS AppSync DynamoDB que realice una `DeleteItem` solicitud a DynamoDB y le permite especificar lo siguiente:
+ La clave del elemento de DynamoDB
+ Condiciones para que la operación se lleve a cabo correctamente.
La solicitud `DeleteItem` tiene la estructura siguiente:
```
type DynamoDBDeleteItemRequest = {
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: ConditionCheckExpression;
customPartitionKey?: string;
populateIndexFields?: boolean;
_version?: number;
};
```
Los campos se definen de la siguiente manera:
## DeleteItem campos
### DeleteItem lista de campos
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `DeleteItem`, este valor se debe establecer en `DeleteItem`. Este valor es obligatorio.
** `key` **
La clave del elemento de DynamoDB. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
** `condition` **
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `DeleteItem` elimina un elemento independientemente de su estado actual. Para obtener más información sobre las condiciones, consulte [Expresiones de condición](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-condition-expressions). Este valor es opcional.
** `_version` **
Valor numérico que representa la última versión conocida de un elemento. Este valor es opcional. Este campo se utiliza para *detectar conflictos* y solo se admite en orígenes de datos con control de versiones.
**`customPartitionKey`**
Cuando está activado, este valor de cadena modifica el formato `ds_sk` y los `ds_pk` registros que utiliza la tabla de sincronización delta cuando se ha activado el control de versiones (para obtener más información, consulte [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 AWS AppSync desarrolladores*). Cuando se habilita, también lo hace el procesamiento de la entrada `populateIndexFields`. Este campo es opcional.
**`populateIndexFields`**
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 *. Este campo es opcional.
El elemento que se elimina de DynamoDB se convierte automáticamente a los tipos primitivos de GraphQL y JSON, y está disponible en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
[Para obtener más información sobre los JavaScript solucionadores, consulta JavaScript la descripción general de los solucionadores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
## Ejemplo 1
El siguiente ejemplo es un controlador de solicitudes de función para una mutación de GraphQL `deleteItem(id: ID!)`. Si ya existe un elemento con este ID, se eliminará.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id: ctx.args.id }),
};
}
```
## Ejemplo 2
El siguiente ejemplo es un controlador de solicitudes de función para una mutación de GraphQL `deleteItem(id: ID!, expectedVersion: Int!)`. Si ya existe un elemento con este ID, se eliminará, pero solo si su campo `version` está establecido en `expectedVersion`:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, expectedVersion } = ctx.args;
const condition = {
id: { attributeExists: true },
version: { eq: expectedVersion },
};
return {
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ id }),
condition: util.transform.toDynamoDBConditionExpression(condition),
};
}
```
Para obtener más información sobre la API `DeleteItem` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).
# Consultar
El objeto de `Query` solicitud le permite indicar a la resolución de AWS AppSync DynamoDB que realice `Query` una solicitud a DynamoDB y le permite especificar lo siguiente:
+ Expresión de clave.
+ Qué índice utilizar.
+ Todos los filtros adicionales.
+ Cuántos elementos deben devolverse.
+ Si se utilizarán lecturas coherentes.
+ Dirección de consulta (hacia delante o hacia atrás).
+ Token de paginación
El objeto de solicitud `Query` tiene la siguiente estructura:
```
type DynamoDBQueryRequest = {
operation: 'Query';
query: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
index?: string;
nextToken?: string;
limit?: number;
scanIndexForward?: boolean;
consistentRead?: boolean;
select?: 'ALL_ATTRIBUTES' | 'ALL_PROJECTED_ATTRIBUTES' | 'SPECIFIC_ATTRIBUTES';
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Los campos se definen de la siguiente manera:
## Campos de consulta
### Lista de campos de consulta
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `Query`, este valor se debe establecer en `Query`. Este valor es obligatorio.
** `query` **
La sección `query` permite especificar una expresión de condición de clave que describe qué elementos deben recuperarse de DynamoDB. Para obtener más información sobre cómo escribir expresiones de condiciones clave, consulte la documentación de [ KeyConditions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Esta sección debe especificarse.
** `expression` **
La expresión de la consulta. Este campo debe especificarse.
** `expressionNames` **
Las sustituciones de los marcadores de posición de *nombre* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre usado en la `expression` y el valor tiene que ser una cadena que corresponda al nombre de atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de marcadores de posición de nombre de atributo de expresión que se usen en la `expression`.
** `expressionValues` **
Las sustituciones de los marcadores de posición de *valor* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la `expression` y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la `expression`.
** `filter` **
Un filtro adicional que se puede utilizar para filtrar los resultados de DynamoDB antes de que se devuelvan. Para obtener más información acerca de los filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Este campo es opcional.
** `index` **
El nombre del índice que se consultará. La operación de consulta de DynamoDB permite escanear en índices secundarios locales y globales además de hacerlo en el índice de clave principal de una clave hash. Si se especifica, indica a DynamoDB que debe consultar el índice especificado. Si se omite, se consultará el índice de clave principal.
** `nextToken` **
El token de paginación para continuar una consulta anterior. Se debe obtener de una consulta anterior. Este campo es opcional.
** `limit` **
Número máximo de elementos que se van a evaluar, que no es necesariamente el número de elementos coincidentes. Este campo es opcional.
** `scanIndexForward` **
Valor booleano que indica si se debe consultar hacia delante o hacia atrás. Este campo es opcional y de forma predeterminada es `true`.
** `consistentRead` **
Valor booleano que indica si se utilizarán lecturas coherentes al consultar DynamoDB. Este campo es opcional y de forma predeterminada es `false`.
** `select` **
De forma predeterminada, el solucionador de AWS AppSync DynamoDB solo devuelve los atributos que se proyectan en el índice. Si se necesitan más atributos, puede configurar este campo. Este campo es opcional. 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` **
Permitido solo al consultar un índice. Recupera 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 la `expression` de la `projection`. Este valor devuelto equivale a especificar la `expression` de la `projection` sin especificar ningún valor para `Select`.
**`projection`**
Proyección que se utiliza para especificar los atributos que se devolverán de la operación de DynamoDB. Para obtener más información acerca de las proyecciones, consulte la sección [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Este campo es opcional.
Los resultados de DynamoDB se convierten automáticamente a los tipos primitivos de GraphQL y JSON, y están disponibles en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
[Para obtener más información sobre los JavaScript resolutores, consulte JavaScript Información general sobre los resolutores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
Los resultados tienen la estructura siguiente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Los campos se definen de la siguiente manera:
** `items` **
Una lista que contiene los elementos que devuelve la consulta de DynamoDB.
** `nextToken` **
Si hubiera más resultados, `nextToken` contiene un token de paginación que puede usar en otra solicitud. Tenga en cuenta que AWS AppSync cifra y oculta el token de paginación devuelto por DynamoDB. Esto evita que los datos de las tablas se filtren accidentalmente al intermediario. Además, tenga en cuenta que estos tokens de paginación no se pueden utilizar en diferentes funciones o solucionadores.
** `scannedCount` **
El número de elementos que coincidían con la expresión de condición de consulta antes de aplicar una expresión de filtro (si la hay).
## Ejemplo
El siguiente ejemplo es un controlador de solicitudes de función para una consulta de GraphQL `getPosts(owner: ID!)`.
En este ejemplo, se consulta un índice secundario global en una tabla para que devuelva todas las publicaciones que pertenecen al ID especificado.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { owner } = ctx.args;
return {
operation: 'Query',
query: {
expression: 'ownerId = :ownerId',
expressionValues: util.dynamodb.toMapValues({ ':ownerId': owner }),
},
index: 'owner-index',
};
}
```
Para obtener más información sobre la API `Query` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).
# Examen
La `Scan` solicitud le permite indicar a la función de AWS AppSync DynamoDB que realice una `Scan` solicitud a DynamoDB y le permite especificar lo siguiente:
+ Un filtro para excluir resultados
+ Qué índice utilizar.
+ Cuántos elementos deben devolverse.
+ Si se utilizarán lecturas coherentes.
+ Token de paginación
+ Exámenes en paralelo
El objeto de solicitud `Scan` tiene la siguiente estructura:
```
type DynamoDBScanRequest = {
operation: 'Scan';
index?: string;
limit?: number;
consistentRead?: boolean;
nextToken?: string;
totalSegments?: number;
segment?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
```
Los campos se definen de la siguiente manera:
## Campos de Scan
### Lista de campos de Scan
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `Scan`, este valor se debe establecer en `Scan`. Este valor es obligatorio.
** `filter` **
Un filtro que se puede utilizar para filtrar los resultados de DynamoDB antes de que se devuelvan. Para obtener más información acerca de los filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Este campo es opcional.
** `index` **
El nombre del índice que se consultará. La operación de consulta de DynamoDB permite escanear en índices secundarios locales y globales además de hacerlo en el índice de clave principal de una clave hash. Si se especifica, indica a DynamoDB que debe consultar el índice especificado. Si se omite, se consultará el índice de clave principal.
** `limit` **
El número máximo de elementos que se evalúan en una sola vez. Este campo es opcional.
** `consistentRead` **
Valor booleano que indica si se utilizarán lecturas coherentes al consultar DynamoDB. Este campo es opcional y de forma predeterminada es `false`.
** `nextToken` **
El token de paginación para continuar una consulta anterior. Se debe obtener de una consulta anterior. Este campo es opcional.
** `select` **
De forma predeterminada, la función AWS AppSync DynamoDB solo devuelve los atributos que se proyectan en el índice. Si se necesitan más atributos, este campo se puede configurar. Este campo es opcional. 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` **
Permitido solo al consultar un índice. Recupera 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 la `expression` de la `projection`. Este valor devuelto equivale a especificar la `expression` de la `projection` sin especificar ningún valor para `Select`.
** `totalSegments` **
El número de segmentos para dividir en particiones la tabla al realizar un examen paralelo. Este campo es opcional, pero debe especificarse si se indica `segment`.
** `segment` **
El segmento de tabla de esta operación al realizar un examen en paralelo. Este campo es opcional, pero debe especificarse si se indica `totalSegments`.
**`projection`**
Proyección que se utiliza para especificar los atributos que se devolverán de la operación de DynamoDB. Para obtener más información acerca de las proyecciones, consulte la sección [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Este campo es opcional.
Los resultados que el examen de DynamoDB devuelve se convierten automáticamente a los tipos primitivos de GraphQL y JSON, y están disponibles en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
[Para obtener más información sobre los JavaScript resolutores, consulte JavaScript la descripción general de los resolutores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
Los resultados tienen la estructura siguiente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10
}
```
Los campos se definen de la siguiente manera:
** `items` **
Una lista que contiene los elementos que devuelve el análisis de DynamoDB.
** `nextToken` **
Si hay más resultados, `nextToken` contiene un token de paginación que puedes usar en otra solicitud. AWS AppSync cifra y oculta el token de paginación devuelto por DynamoDB. Esto evita que los datos de las tablas se filtren accidentalmente al intermediario. Además, estos tokens de paginación no se pueden utilizar en diferentes funciones o solucionadores.
** `scannedCount` **
El número de elementos que DynamoDB ha recuperado antes de aplicar una expresión de filtro (en caso de incluirse).
## Ejemplo 1
El siguiente ejemplo es un controlador de solicitudes de función para la consulta de GraphQL: `allPosts`.
En este ejemplo, se devuelven todas las entradas de la tabla.
```
export function request(ctx) {
return { operation: 'Scan' };
}
```
## Ejemplo 2
El siguiente ejemplo es un controlador de solicitudes de función para la consulta de GraphQL: `postsMatching(title: String!)`.
En este ejemplo, todas las entradas de la tabla se devuelven donde el título comienza con el argumento `title`.
```
export function request(ctx) {
const { title } = ctx.args;
const filter = { filter: { beginsWith: title } };
return {
operation: 'Scan',
filter: JSON.parse(util.transform.toDynamoDBFilterExpression(filter)),
};
}
```
Para obtener más información sobre la API `Scan` de DynamoDB, consulte la [documentación de la API de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).
# Sincronizar
El objeto de solicitud `Sync` permite recuperar todos los resultados de una tabla de DynamoDB y, a continuación, recibir tan solo los datos alterados desde la última consulta (las actualizaciones delta). Únicamente se pueden realizar solicitudes `Sync` a orígenes de datos con control de versiones de DynamoDB. Puede especificar lo siguiente:
+ Un filtro para excluir resultados
+ Cuántos elementos deben devolverse.
+ Token de paginación
+ Cuando se inició la última operación `Sync`
El objeto de solicitud `Sync` tiene la siguiente estructura:
```
type DynamoDBSyncRequest = {
operation: 'Sync';
basePartitionKey?: string;
deltaIndexName?: string;
limit?: number;
nextToken?: string;
lastSync?: number;
filter?: {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: any };
};
};
```
Los campos se definen de la siguiente manera:
## Campos de Sync
### Lista de campos de Sync
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación `Sync` de , en este valor debe establecerse `Sync`. Este valor es obligatorio.
** `filter` **
Un filtro que se puede utilizar para filtrar los resultados de DynamoDB antes de que se devuelvan. Para obtener más información acerca de los filtros, consulte [Filtros](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-filter). Este campo es opcional.
** `limit` **
El número máximo de elementos que se evalúan en una sola vez. Este campo es opcional. Si se omite, el límite predeterminado se establecerá en `100` elementos. El valor máximo de este campo son `1000` elementos.
** `nextToken` **
El token de paginación para continuar una consulta anterior. Se debe obtener de una consulta anterior. Este campo es opcional.
** `lastSync` **
El 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 es opcional y 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*.
**`basePartitionKey`**
Clave de partición de la tabla *Base* utilizada al realizar una operación `Sync`. Este campo permite realizar una operación `Sync` cuando la tabla utiliza una clave de partición personalizada. Se trata de un campo opcional.
**`deltaIndexName`**
Í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`). Este campo es opcional.
Los resultados que la sincronización de DynamoDB devuelve se convierten automáticamente a los tipos primitivos de GraphQL y JSON, y están disponibles en el resultado del contexto (`context.result`).
Para obtener más información sobre la conversión de tipos de DynamoDB, consulte la sección [Sistema de tipos (mapeo de respuestas)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-responses).
Para obtener más información sobre los JavaScript resolutores, consulte la descripción general de los [JavaScript resolutores.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
Los resultados tienen la estructura siguiente:
```
{
items = [ ... ],
nextToken = "a pagination token",
scannedCount = 10,
startedAt = 1550000000000
}
```
Los campos se definen de la siguiente manera:
** `items` **
Una lista que contiene los elementos que devuelve la sincronización.
** `nextToken` **
Si hay más resultados, `nextToken` contiene un token de paginación que puedes usar en otra solicitud. AWS AppSync cifra y oculta el token de paginación devuelto por DynamoDB. Esto evita que los datos de las tablas se filtren accidentalmente al intermediario. Además, estos tokens de paginación no se pueden utilizar en diferentes funciones o solucionadores.
** `scannedCount` **
El número de elementos que DynamoDB ha recuperado antes de aplicar una expresión de filtro (en caso de incluirse).
** `startedAt` **
El momento, en milisegundos transcurridos desde la fecha de inicio, en el que comenzó la operación de sincronización que puede almacenar localmente y usar en otra solicitud como argumento de `lastSync`. Si se incluyó un token de paginación en la solicitud, este valor será el mismo que el devuelto por la solicitud para la primera página de resultados.
## Ejemplo
El siguiente ejemplo es un controlador de solicitudes de función para la consulta de GraphQL: `syncPosts(nextToken: String, lastSync: AWSTimestamp)`.
En este ejemplo, si se omite `lastSync`, se devuelven todas las entradas de la tabla base. Si se proporciona `lastSync`, solo se devuelven las entradas de la tabla Delta Sync que han cambiado desde `lastSync`.
```
export function request(ctx) {
const { nextToken, lastSync } = ctx.args;
return { operation: 'Sync', limit: 100, nextToken, lastSync };
}
```
# BatchGetItem
El objeto de `BatchGetItem` solicitud permite indicar a la función de AWS AppSync DynamoDB que realice una `BatchGetItem` solicitud a DynamoDB para recuperar varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar lo siguiente:
+ Los nombres de tabla de los que recuperar los elementos
+ Las claves de los elementos que recuperar de cada tabla
Se aplican los límites de `BatchGetItem` de DynamoDB y no puede proporcionar **ninguna expresión de condición**.
El objeto de solicitud `BatchGetItem` tiene la siguiente estructura:
```
type DynamoDBBatchGetItemRequest = {
operation: 'BatchGetItem';
tables: {
[tableName: string]: {
keys: { [key: string]: any }[];
consistentRead?: boolean;
projection?: {
expression: string;
expressionNames?: { [key: string]: string };
};
};
};
};
```
Los campos se definen de la siguiente manera:
## BatchGetItem campos
### BatchGetItem lista de campos
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `BatchGetItem`, este valor se debe establecer en `BatchGetItem`. Este valor es obligatorio.
** `tables` **
Las tablas de DynamoDB de las que recuperar los elementos. El valor es un mapa en el que se especifican los nombres de las tablas como claves del mapa. Al menos debe proporcionarse una tabla. Este valor `tables` es obligatorio.
** `keys` **
Lista de claves de DynamoDB que representan la clave principal de los elementos que se van a recuperar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request).
** `consistentRead` **
Si se debe utilizar una lectura coherente al ejecutar una *GetItem*operación. Este valor es opcional y de forma predeterminada es *falso*.
**`projection`**
Proyección que se utiliza para especificar los atributos que se devolverán de la operación de DynamoDB. Para obtener más información acerca de las proyecciones, consulte la sección [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Este campo es opcional.
Cosas que tener en cuenta:
+ Si un elemento no se ha recuperado de la tabla, aparece un elemento *nulo* en el bloque de datos para esa tabla.
+ Los resultados de invocación se ordenan por tabla, según el orden en el que se hayan proporcionado dentro del objeto de solicitud.
+ Cada comando `Get` dentro de un `BatchGetItem` es atómico, sin embargo, un lote se puede procesar parcialmente. Si un lote se procesa parcialmente debido a un error, la claves sin procesar se devuelven como parte del resultado de invocación dentro del bloque *unprocessedKeys*.
+ `BatchGetItem` está limitado a 100 claves.
Para el siguiente controlador de solicitudes de función de ejemplo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchGetItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
El resultado de invocación disponible en `ctx.result` es el siguiente:
```
{
"data": {
"authors": [null],
"posts": [
// Was retrieved
{
"authorId": "a1",
"postId": "p2",
"postTitle": "title",
"postDescription": "description",
}
]
},
"unprocessedKeys": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
El `ctx.error` contiene detalles acerca del error. Está garantizado que los **datos** de claves, **unprocessedKeys** y cada clave de tabla que se proporcionó en el resultado del objeto de solicitud de función estarán presentes en el resultado de invocación. Los elementos que se han eliminado aparecen en el bloque de **datos**. Los elementos que no se hayan procesado se marcan como *null* dentro del bloque de datos y se colocan dentro del bloque **unprocessedKeys**.
# BatchDeleteItem
El objeto de `BatchDeleteItem` solicitud permite indicar a la función de AWS AppSync DynamoDB que `BatchWriteItem` solicite a DynamoDB la eliminación de varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar lo siguiente:
+ Los nombres de tabla de los que eliminar los elementos
+ Las claves de los elementos que eliminar de cada tabla
Se aplican los límites de `BatchWriteItem` de DynamoDB y no puede proporcionar **ninguna expresión de condición**.
El objeto de solicitud `BatchDeleteItem` tiene la siguiente estructura:
```
type DynamoDBBatchDeleteItemRequest = {
operation: 'BatchDeleteItem';
tables: {
[tableName: string]: { [key: string]: any }[];
};
};
```
Los campos se definen de la siguiente manera:
## BatchDeleteItem campos
### BatchDeleteItem lista de campos
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `BatchDeleteItem`, este valor se debe establecer en `BatchDeleteItem`. Este valor es obligatorio.
** `tables` **
Las tablas de DynamoDB de las que eliminar los elementos. Cada tabla es una lista de claves de DynamoDB que representan la clave principal de los elementos que se van a eliminar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Al menos debe proporcionarse una tabla. El valor `tables` es obligatorio.
Cosas que tener en cuenta:
+ Al contrario que en la operación `DeleteItem`, el elemento completamente eliminado no se devuelve en la respuesta. Solo se devuelve la clave pasada.
+ Si un elemento no se ha eliminado de la tabla, aparece un elemento *nulo* en el bloque de datos para esa tabla.
+ Los resultados de invocación se ordenan por tabla, según el orden en el que se hayan proporcionado dentro del objeto de solicitud.
+ Cada comando `Delete` dentro de un `BatchDeleteItem` es atómico. Sin embargo, un lote puede procesarse parcialmente. Si un lote se procesa parcialmente debido a un error, la claves sin procesar se devuelven como parte del resultado de invocación dentro del bloque *unprocessedKeys*.
+ `BatchDeleteItem` está limitado a 25 claves.
+ Esta operación **no** se admite cuando se utiliza con la detección de conflictos. El uso de ambas al mismo tiempo generará un error.
Para el siguiente controlador de solicitudes de función de ejemplo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'BatchDeleteItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId })],
posts: [util.dynamodb.toMapValues({ authorId, postId })],
},
};
}
```
El resultado de invocación disponible en `ctx.result` es el siguiente:
```
{
"data": {
"authors": [null],
"posts": [
// Was deleted
{
"authorId": "a1",
"postId": "p2"
}
]
},
"unprocessedKeys": {
"authors": [
// This key was not processed due to an error
{
"authorId": "a1"
}
],
"posts": []
}
}
```
El `ctx.error` contiene detalles acerca del error. Está garantizado que los **datos** de claves, **unprocessedKeys** y cada clave de tabla que se proporcionó en el objeto de solicitud de función estarán presentes en el resultado de invocación. Los elementos que se han eliminado están presentes en el bloque de **datos**. Los elementos que no se hayan procesado se marcan como *null* dentro del bloque de datos y se colocan dentro del bloque **unprocessedKeys**.
# BatchPutItem
El objeto de `BatchPutItem` solicitud permite indicar a la función de AWS AppSync DynamoDB que realice una `BatchWriteItem` solicitud a DynamoDB para colocar varios elementos, posiblemente en varias tablas. Para este objeto de solicitud, debe especificar lo siguiente:
+ Los nombres de tabla en los que poner los elementos
+ Los elementos completos que poner en cada tabla
Se aplican los límites de `BatchWriteItem` de DynamoDB y no puede proporcionar **ninguna expresión de condición**.
El objeto de solicitud `BatchPutItem` tiene la siguiente estructura:
```
type DynamoDBBatchPutItemRequest = {
operation: 'BatchPutItem';
tables: {
[tableName: string]: { [key: string]: any}[];
};
};
```
Los campos se definen de la siguiente manera:
## BatchPutItem campos
### BatchPutItem lista de campos
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `BatchPutItem`, este valor se debe establecer en `BatchPutItem`. Este valor es obligatorio.
** `tables` **
Las tablas de DynamoDB en las que poner los elementos. Cada entrada de la tabla representa una lista de elementos de DynamoDB que insertar para esta tabla específica. Al menos debe proporcionarse una tabla. Este valor es obligatorio.
Cosas que tener en cuenta:
+ Los elementos totalmente insertados se devuelven en la respuesta, si la operación se realiza correctamente.
+ Si un elemento no se ha insertado en la tabla, aparece un elemento *nulo* en el bloque de datos para esa tabla.
+ Los elementos insertados se ordenan por tabla, según el orden en el que se hayan proporcionado dentro del objeto de solicitud.
+ Cada comando `Put` dentro de un `BatchPutItem` es atómico, sin embargo, un lote se puede procesar parcialmente. Si un lote se procesa parcialmente debido a un error, la claves sin procesar se devuelven como parte del resultado de invocación dentro del bloque *unprocessedKeys*.
+ `BatchPutItem` está limitado a 25 elementos.
+ Esta operación **no** se admite cuando se utiliza con la detección de conflictos. El uso de ambas al mismo tiempo generará un error.
Para el siguiente controlador de solicitudes de función de ejemplo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, name, title } = ctx.args;
return {
operation: 'BatchPutItem',
tables: {
authors: [util.dynamodb.toMapValues({ authorId, name })],
posts: [util.dynamodb.toMapValues({ authorId, postId, title })],
},
};
}
```
El resultado de invocación disponible en `ctx.result` es el siguiente:
```
{
"data": {
"authors": [
null
],
"posts": [
// Was inserted
{
"authorId": "a1",
"postId": "p2",
"title": "title"
}
]
},
"unprocessedItems": {
"authors": [
// This item was not processed due to an error
{
"authorId": "a1",
"name": "a1_name"
}
],
"posts": []
}
}
```
El `ctx.error` contiene detalles acerca del error. Está garantizado que los **datos** de claves, **unprocessedItems** y cada clave de tabla que se proporcionó en el objeto de solicitud estarán presentes en el resultado de invocación. Los elementos que se han insertado están en el bloque de **datos**. Los elementos que no se hayan procesado se marcan como *null* dentro del bloque de datos y se colocan dentro del bloque **unprocessedItems**.
# TransactGetItems
El objeto de `TransactGetItems` solicitud le permite indicar a la función de AWS AppSync DynamoDB que realice una `TransactGetItems` solicitud a DynamoDB para recuperar varios elementos, posiblemente de varias tablas. Para este objeto de solicitud, debe especificar lo siguiente:
+ El nombre de la tabla de cada elemento de solicitud de la que se va a recuperar el elemento
+ La clave de cada elemento de solicitud que se va a recuperar de cada tabla
Se aplican los límites de `TransactGetItems` de DynamoDB y no puede proporcionar **ninguna expresión de condición**.
El objeto de solicitud `TransactGetItems` tiene la siguiente estructura:
```
type DynamoDBTransactGetItemsRequest = {
operation: 'TransactGetItems';
transactItems: { table: string; key: { [key: string]: any }; projection?: { expression: string; expressionNames?: { [key: string]: string }; }[];
};
};
```
Los campos se definen de la siguiente manera:
## TransactGetItems campos
### TransactGetItems lista de campos
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `TransactGetItems`, este valor se debe establecer en `TransactGetItems`. Este valor es obligatorio.
** `transactItems` **
Los elementos de solicitud que se van a incluir. El valor es una matriz de elementos de solicitud. Se debe proporcionar al menos un elemento de solicitud. Este valor `transactItems` es obligatorio.
** `table` **
La tabla de DynamoDB de la que se va a recuperar el elemento. El valor es una cadena con el nombre de la tabla. Este valor `table` es obligatorio.
** `key` **
La clave de DynamoDB que representa la clave principal del elemento que se desea recuperar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request).
**`projection`**
Proyección que se utiliza para especificar los atributos que se devolverán de la operación de DynamoDB. Para obtener más información acerca de las proyecciones, consulte la sección [Proyecciones](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-projections). Este campo es opcional.
Cosas que tener en cuenta:
+ Si una transacción se realiza correctamente, el orden de los elementos recuperados en el bloque `items` será el mismo que el orden de los elementos de solicitud.
+ Las transacciones se realizan de all-or-nothing alguna manera. Si algún elemento de solicitud causa un error, no se realizará la transacción completa y se devolverán los detalles del error.
+ El hecho de no poder recuperar un elemento de solicitud no es un error. En su lugar, aparece un elemento *null* en el bloque *items (elementos)* en la posición correspondiente.
+ Si se trata de un error en la transacción *TransactionCanceledException*, se rellenará el `cancellationReasons` bloque. El orden de los motivos de cancelación en el bloque `cancellationReasons` será el mismo que el orden de los elementos de solicitud.
+ `TransactGetItems` está limitado a 100 elementos de solicitud.
Para el siguiente controlador de solicitudes de función de ejemplo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId } = ctx.args;
return {
operation: 'TransactGetItems',
transactItems: [
{
table: 'posts',
key: util.dynamodb.toMapValues({ postId }),
},
{
table: 'authors',
key: util.dynamodb.toMapValues({ authorId }),
},
],
};
}
```
Si la transacción se realiza correctamente y solo se recupera el primer elemento solicitado, el resultado de la invocación disponible en `ctx.result` es el siguiente:
```
{
"items": [
{
// Attributes of the first requested item
"post_id": "p1",
"post_title": "title",
"post_description": "description"
},
// Could not retrieve the second requested item
null,
],
"cancellationReasons": null
}
```
Si la transacción falla *TransactionCanceledException*debido al primer elemento solicitado, el resultado de la invocación disponible `ctx.result` es el siguiente:
```
{
"items": null,
"cancellationReasons": [
{
"type":"Sample error type",
"message":"Sample error message"
},
{
"type":"None",
"message":"None"
}
]
}
```
El `ctx.error` contiene detalles acerca del error. Los valores de **items** de claves y **cancellationReasons** estarán presentes sin duda en `ctx.result`.
# TransactWriteItems
El objeto de `TransactWriteItems` solicitud permite indicar a la función de AWS AppSync DynamoDB que realice una `TransactWriteItems` solicitud a DynamoDB para escribir varios elementos, posiblemente en varias tablas. Para este objeto de solicitud, debe especificar lo siguiente:
+ El nombre de la tabla de destino de cada elemento de solicitud
+ La operación de cada elemento de solicitud que se va a realizar. Se admiten cuatro tipos de operaciones: *PutItem*,, y *UpdateItem*DeleteItem*ConditionCheck***
+ La clave de cada elemento de solicitud que se va a escribir
Se aplican los límites de `TransactWriteItems` de DynamoDB.
El objeto de solicitud `TransactWriteItems` tiene la siguiente estructura:
```
type DynamoDBTransactWriteItemsRequest = {
operation: 'TransactWriteItems';
transactItems: TransactItem[];
};
type TransactItem =
| TransactWritePutItem
| TransactWriteUpdateItem
| TransactWriteDeleteItem
| TransactWriteConditionCheckItem;
type TransactWritePutItem = {
table: string;
operation: 'PutItem';
key: { [key: string]: any };
attributeValues: { [key: string]: string};
condition?: TransactConditionCheckExpression;
};
type TransactWriteUpdateItem = {
table: string;
operation: 'UpdateItem';
key: { [key: string]: any };
update: DynamoDBExpression;
condition?: TransactConditionCheckExpression;
};
type TransactWriteDeleteItem = {
table: string;
operation: 'DeleteItem';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactWriteConditionCheckItem = {
table: string;
operation: 'ConditionCheck';
key: { [key: string]: any };
condition?: TransactConditionCheckExpression;
};
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
returnValuesOnConditionCheckFailure: boolean;
};
```
## TransactWriteItems campos
### TransactWriteItems lista de campos
**Los campos se definen de la siguiente manera: **
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `TransactWriteItems`, este valor se debe establecer en `TransactWriteItems`. Este valor es obligatorio.
** `transactItems` **
Los elementos de solicitud que se van a incluir. El valor es una matriz de elementos de solicitud. Se debe proporcionar al menos un elemento de solicitud. Este valor `transactItems` es obligatorio.
Para `PutItem`, los campos se definen de la siguiente manera:
** `table` **
La tabla de DynamoDB de destino. El valor es una cadena con el nombre de la tabla. Este valor `table` es obligatorio.
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `PutItem`, este valor se debe establecer en `PutItem`. Este valor es obligatorio.
** `key` **
La clave de DynamoDB que representa la clave principal del elemento que se desea colocar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
** `attributeValues` **
El resto de los atributos del elemento que debe colocarse en DynamoDB. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este campo es opcional.
** `condition` **
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `PutItem` sobrescribe todas las entradas existentes para dicho elemento. Puede especificar si desea recuperar el elemento existente cuando se produzca un error en la comprobación de condiciones. Para obtener más información acerca de las condiciones transaccionales, consulte [Expresiones de condición de transacción](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor es opcional.
Para `UpdateItem`, los campos se definen de la siguiente manera:
** `table` **
La tabla de DynamoDB que se va a actualizar. El valor es una cadena con el nombre de la tabla. Este valor `table` es obligatorio.
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `UpdateItem`, este valor se debe establecer en `UpdateItem`. Este valor es obligatorio.
** `key` **
La clave de DynamoDB que representa la clave principal del elemento que se va a actualizar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
** `update` **
La sección `update` permite especificar una expresión de actualización que describe cómo se actualiza el elemento en DynamoDB. Para obtener más información sobre cómo escribir expresiones de actualización, consulte la documentación de [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Esta sección es obligatoria.
** `condition` **
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `UpdateItem` actualiza todas las entradas existentes independientemente de su estado actual. Puede especificar si desea recuperar el elemento existente cuando se produzca un error en la comprobación de condiciones. Para obtener más información acerca de las condiciones transaccionales, consulte [Expresiones de condición de transacción](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor es opcional.
Para `DeleteItem`, los campos se definen de la siguiente manera:
** `table` **
La tabla de DynamoDB en la que se elimina el elemento. El valor es una cadena con el nombre de la tabla. Este valor `table` es obligatorio.
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `DeleteItem`, este valor se debe establecer en `DeleteItem`. Este valor es obligatorio.
** `key` **
La clave de DynamoDB que representa la clave principal del elemento que se desea eliminar. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
** `condition` **
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Si no se especifica ninguna condición, la solicitud `DeleteItem` elimina un elemento independientemente de su estado actual. Puede especificar si desea recuperar el elemento existente cuando se produzca un error en la comprobación de condiciones. Para obtener más información acerca de las condiciones transaccionales, consulte [Expresiones de condición de transacción](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor es opcional.
Para `ConditionCheck`, los campos se definen de la siguiente manera:
** `table` **
La tabla de DynamoDB en la que se comprueba la condición. El valor es una cadena con el nombre de la tabla. Este valor `table` es obligatorio.
** `operation` **
La operación de DynamoDB que se ha de realizar. Para ejecutar la operación de DynamoDB `ConditionCheck`, este valor se debe establecer en `ConditionCheck`. Este valor es obligatorio.
** `key` **
La clave de DynamoDB que representa la clave principal del elemento que hay que someter a una comprobación de condición. Los elementos de DynamoDB pueden tener solo una clave hash o una clave hash y una clave de clasificación, dependiendo de la estructura de la tabla. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor es obligatorio.
** `condition` **
Una condición para determinar si la solicitud debe realizarse correctamente o no, en función del estado del objeto ya incluido en DynamoDB. Puede especificar si desea recuperar el elemento existente cuando se produzca un error en la comprobación de condiciones. Para obtener más información acerca de las condiciones transaccionales, consulte [Expresiones de condición de transacción](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-transaction-condition-expressions). Este valor es obligatorio.
Cosas que tener en cuenta:
+ Solo las claves de los elementos de solicitud se devuelven en la respuesta, si se realiza correctamente. El orden de las claves será el mismo que el orden de los elementos de solicitud.
+ Las transacciones se realizan de alguna manera all-or-nothing. Si algún elemento de solicitud causa un error, no se realizará la transacción completa y se devolverán los detalles del error.
+ No se pueden dirigir dos elementos de solicitud al mismo elemento. De lo contrario, provocarán *TransactionCanceledException*un error.
+ Si se trata de un error en la transacción *TransactionCanceledException*, se rellenará el `cancellationReasons` bloque. Si se produce un error en la comprobación de condición de un elemento de solicitud **y** no se ha especificado que `returnValuesOnConditionCheckFailure` sea `false`, el elemento existente en la tabla se recuperará y almacenará en `item` en la posición correspondiente del bloque `cancellationReasons`.
+ `TransactWriteItems` está limitado a 100 elementos de solicitud.
+ Esta operación **no** se admite cuando se utiliza con la detección de conflictos. El uso de ambas al mismo tiempo generará un error.
Para el siguiente controlador de solicitudes de función de ejemplo:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { authorId, postId, title, description, oldTitle, authorName } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'PutItem',
key: util.dynamodb.toMapValues({ postId }),
attributeValues: util.dynamodb.toMapValues({ title, description }),
condition: util.transform.toDynamoDBConditionExpression({
title: { eq: oldTitle },
}),
},
{
table: 'authors',
operation: 'UpdateItem',
key: util.dynamodb.toMapValues({ authorId }),
update: {
expression: 'SET authorName = :name',
expressionValues: util.dynamodb.toMapValues({ ':name': authorName }),
},
},
],
};
}
```
Si la transacción se realiza correctamente, el resultado de la invocación disponible en `ctx.result` es el siguiente:
```
{
"keys": [
// Key of the PutItem request
{
"post_id": "p1",
},
// Key of the UpdateItem request
{
"author_id": "a1"
}
],
"cancellationReasons": null
}
```
Si la transacción no se realiza correctamente debido a un error de comprobación de condición de la solicitud `PutItem`, el resultado de la invocación disponible en `ctx.result` es el siguiente:
```
{
"keys": null,
"cancellationReasons": [
{
"item": {
"post_id": "p1",
"post_title": "Actual old title",
"post_description": "Old description"
},
"type": "ConditionCheckFailed",
"message": "The condition check failed."
},
{
"type": "None",
"message": "None"
}
]
}
```
El `ctx.error` contiene detalles acerca del error. Los valores de **keys** y **cancellationReasons** estarán presentes sin duda en `ctx.result`.
# Sistema de tipos (mapeo de solicitud)
Al utilizar la función AWS AppSync DynamoDB para llamar a las tablas de DynamoDB AWS AppSync , necesita saber el tipo de cada valor que se va a utilizar en esa llamada. Esto se debe a que DynamoDB admite más primitivas de tipo que GraphQL o JSON (como conjuntos y datos binarios). AWS AppSync necesita algunas sugerencias al traducir entre GraphQL y DynamoDB; de lo contrario, tendría que hacer algunas suposiciones sobre cómo se estructuran los datos en la tabla.
Para obtener más información sobre los tipos de datos de DynamoDB, consulte la documentación relativa a los [descriptores de tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors) y los [tipos de datos](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) de DynamoDB.
Un valor de DynamoDB se representa mediante un objeto JSON que contiene un único par de clave-valor. La clave especifica el tipo de DynamoDB y el valor especifica el valor en sí. En el siguiente ejemplo, la clave `S` indica que el valor es una cadena y el valor `identifier` es el valor de la cadena en sí.
```
{ "S" : "identifier" }
```
Tenga en cuenta que el objeto JSON no puede tener más de un par de clave-valor. Si se especifica más de un par de clave-valor, el objeto de solicitud no se analizará.
Siempre que necesite especificar un valor en un objeto de solicitud, deberá usar un valor de DynamoDB. Entre los lugares donde necesitará realizar esta operación figuran: las secciones `key` y `attributeValue`, y la sección `expressionValues` de secciones de expresión. En el siguiente ejemplo, el valor de cadena de DynamoDB `identifier` se asigna al campo `id` de una sección `key` (puede que en un objeto de solicitud `GetItem`).
```
"key" : {
"id" : { "S" : "identifier" }
}
```
**Tipos admitidos**
AWS AppSync admite los siguientes tipos de escalares, documentos y conjuntos de DynamoDB:
**Tipo cadena `S` **
Un valor de cadena único. Un valor de cadena de DynamoDB se indica de la siguiente manera:
```
{ "S" : "some string" }
```
Ejemplo de uso:
```
"key" : {
"id" : { "S" : "some string" }
}
```
**Tipo de conjunto de cadenas `SS` **
Un conjunto de valores de cadena. Un valor de conjunto de cadenas de DynamoDB se indica de la siguiente manera:
```
{ "SS" : [ "first value", "second value", ... ] }
```
Ejemplo de uso:
```
"attributeValues" : {
"phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```
**Tipo número `N` **
Un valor numérico único. Un valor de número de DynamoDB se indica de la siguiente manera:
```
{ "N" : 1234 }
```
Ejemplo de uso:
```
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
}
```
**Tipo conjunto de números `NS` **
Conjunto de valores de número. Un valor de conjunto de números de DynamoDB se indica de la siguiente manera:
```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Ejemplo de uso:
```
"attributeValues" : {
"sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```
**Tipo binario `B` **
Un valor binario. Un valor binario de DynamoDB se indica de la siguiente manera:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Tenga en cuenta que el valor es en realidad una cadena, donde la cadena es la representación codificada en base64 de los datos binarios. AWS AppSync decodifica esta cadena de nuevo en su valor binario antes de enviarla a DynamoDB. AWS AppSync utiliza el esquema de decodificación base64 definido en el RFC 2045: se ignora cualquier carácter que no esté en el alfabeto base64.
Ejemplo de uso:
```
"attributeValues" : {
"binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```
**Tipo conjunto binario `BS` **
Conjunto de valores binarios. Un valor de conjunto binario de DynamoDB se indica de la siguiente manera:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Tenga en cuenta que el valor es en realidad una cadena, donde la cadena es la representación codificada en base64 de los datos binarios. AWS AppSync decodifica esta cadena de nuevo en su valor binario antes de enviarla a DynamoDB. AWS AppSync utiliza el esquema de decodificación base64 definido en el RFC 2045: se ignora cualquier carácter que no esté en el alfabeto base64.
Ejemplo de uso:
```
"attributeValues" : {
"binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```
**Tipo booleano `BOOL` **
Un valor booleano. Un valor booleano de DynamoDB se indica de la siguiente manera:
```
{ "BOOL" : true }
```
Observe que solo los valores `true` y `false` son válidos.
Ejemplo de uso:
```
"attributeValues" : {
"orderComplete" : { "BOOL" : false }
}
```
**Tipo lista `L` **
Lista del resto de valores de DynamoDB admitidos. Un valor de lista de DynamoDB se indica de la siguiente manera:
```
{ "L" : [ ... ] }
```
Observe que se trata de un valor compuesto, y que la lista puede contener cero o más de cualquiera de los valores de DynamoDB admitidos (incluidas otras listas). La lista también puede contener una combinación de diferentes tipos.
Ejemplo de uso:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
**Tipo de mapa `M` **
Representa una colección sin ordenar de pares de clave-valor de otros valores de DynamoDB admitidos. Un valor de mapa de DynamoDB se indica de la siguiente manera:
```
{ "M" : { ... } }
```
Observe que un mapa puede contener cero o más pares clave-valor. La clave tiene que ser una cadena y el valor puede ser cualquier valor de DynamoDB admitido (incluidos otros mapas). El mapa también puede contener una combinación de diferentes tipos.
Ejemplo de uso:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
**Tipo nulo `NULL` **
Un valor nulo. Un valor nulo de DynamoDB se indica de la siguiente manera:
```
{ "NULL" : null }
```
Ejemplo de uso:
```
"attributeValues" : {
"phoneNumbers" : { "NULL" : null }
}
```
Para obtener más información sobre cada tipo, consulte la [documentación de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).
# Sistema de tipos (mapeo de respuestas)
Al recibir una respuesta de DynamoDB, la convierte automáticamente en tipos AWS AppSync primitivos GraphQL y JSON. Cada atributo de DynamoDB se descodifica y se devuelve en el contexto del controlador de respuestas.
Por ejemplo si DynamoDB devuelve lo siguiente:
```
{
"id" : { "S" : "1234" },
"name" : { "S" : "Nadia" },
"age" : { "N" : 25 }
}
```
Cuando tu solucionador de canalizaciones devuelve el resultado, lo AWS AppSync convierte en los tipos GraphQL y JSON de la siguiente manera:
```
{
"id" : "1234",
"name" : "Nadia",
"age" : 25
}
```
En esta sección se explica cómo AWS AppSync se convierten los siguientes tipos de escalares, documentos y conjuntos de DynamoDB:
**Tipo cadena `S` **
Un valor de cadena único. Se devuelve un valor de cadena de DynamoDB en forma de cadena.
Por ejemplo, si DynamoDB devuelve el siguiente valor de cadena de DynamoDB:
```
{ "S" : "some string" }
```
AWS AppSync lo convierte en una cadena:
```
"some string"
```
**Tipo de conjunto de cadenas `SS` **
Un conjunto de valores de cadena. Un valor de conjunto de cadenas de DynamoDB se devuelve como una lista de cadenas.
Por ejemplo, si DynamoDB devuelve el siguiente valor de conjunto de cadenas de DynamoDB:
```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync lo convierte en una lista de cadenas:
```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```
**Tipo número `N` **
Un valor numérico único. Un valor de número de DynamoDB se devuelve como número.
Por ejemplo, si DynamoDB devuelve el siguiente valor de número de DynamoDB:
```
{ "N" : 1234 }
```
AWS AppSync lo convierte en un número:
```
1234
```
**Tipo conjunto de números `NS` **
Conjunto de valores de número. Un valor de conjunto de números de DynamoDB se devuelve como una lista de números.
Por ejemplo, si DynamoDB devuelve el siguiente valor de conjunto de números de DynamoDB:
```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync lo convierte en una lista de números:
```
[ 67.8, 12.2, 70 ]
```
**Tipo binario `B` **
Un valor binario. Un valor binario de DynamoDB se devuelve en forma de cadena que contiene la representación base64 de dicho valor.
Por ejemplo, si DynamoDB devuelve el siguiente valor binario de DynamoDB:
```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync lo convierte en una cadena que contiene la representación en base64 del valor:
```
"SGVsbG8sIFdvcmxkIQo="
```
Observe que los datos binarios se codifican con el esquema base64 como se especifica en [RFC 4648](https://tools.ietf.org/html/rfc4648) y en [RFC 2045](https://tools.ietf.org/html/rfc2045).
**Tipo conjunto binario `BS` **
Conjunto de valores binarios. Un valor de conjunto binario de DynamoDB se devuelve en forma de una lista de cadenas con la representación base64 de los valores.
Por ejemplo, si DynamoDB devuelve el siguiente valor de conjunto binario de DynamoDB:
```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync lo convierte en una lista de cadenas que contienen la representación en base64 de los valores:
```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
Observe que los datos binarios se codifican con el esquema base64 como se especifica en [RFC 4648](https://tools.ietf.org/html/rfc4648) y en [RFC 2045](https://tools.ietf.org/html/rfc2045).
**Tipo booleano `BOOL` **
Un valor booleano. Un valor booleano de DynamoDB se devuelve en forma de valor booleano.
Por ejemplo, si DynamoDB devuelve el siguiente valor booleano de DynamoDB:
```
{ "BOOL" : true }
```
AWS AppSync lo convierte en booleano:
```
true
```
**Tipo lista `L` **
Lista del resto de valores de DynamoDB admitidos. Un valor de lista de DynamoDB se devuelve en forma de lista de valores, donde el valor de cada elemento también se convierte.
Por ejemplo, si DynamoDB devuelve el siguiente valor de lista de DynamoDB:
```
{ "L" : [
{ "S" : "A string value" },
{ "N" : 1 },
{ "SS" : [ "Another string value", "Even more string values!" ] }
]
}
```
AWS AppSync lo convierte en una lista de valores convertidos:
```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```
**Tipo de mapa `M` **
key/value Colección de cualquier otro valor de DynamoDB compatible. Un valor de DynamoDB Map se devuelve como un objeto JSON, donde key/value cada uno de ellos también se convierte.
Por ejemplo, si DynamoDB devuelve el siguiente valor de mapa de DynamoDB:
```
{ "M" : {
"someString" : { "S" : "A string value" },
"someNumber" : { "N" : 1 },
"stringSet" : { "SS" : [ "Another string value", "Even more string values!" ] }
}
}
```
AWS AppSync lo convierte en un objeto JSON:
```
{
"someString" : "A string value",
"someNumber" : 1,
"stringSet" : [ "Another string value", "Even more string values!" ]
}
```
**Tipo nulo `NULL` **
Un valor nulo.
Por ejemplo, si DynamoDB devuelve el siguiente valor nulo de DynamoDB:
```
{ "NULL" : null }
```
AWS AppSync lo convierte en nulo:
```
null
```
# Filtros
Al consultar objetos de DynamoDB mediante las operaciones `Query` y `Scan`, tiene la posibilidad de especificar un `filter` para evaluar los resultados y devolver solo los valores deseados.
La propiedad de filtro de una solicitud `Query` o `Scan` tiene la siguiente estructura:
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
};
```
Los campos se definen de la siguiente manera:
** `expression` **
La expresión de la consulta. Para obtener más información sobre cómo escribir expresiones de filtro, consulte la documentación de [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html) [y QueryFilter ScanFilter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html) DynamoDB. Este campo debe especificarse.
** `expressionNames` **
Las sustituciones de los marcadores de posición de *nombre* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre utilizado en la `expression`. El valor debe ser una cadena que corresponda al nombre del atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de marcadores de posición de nombre de atributo de expresión que se usen en la `expression`.
** `expressionValues` **
Las sustituciones de los marcadores de posición de *valor* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la `expression` y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor debe especificarse. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la `expression`.
## Ejemplo
El siguiente ejemplo es una sección de filtro para una solicitud en la que las entradas obtenidas de DynamoDB solo se devuelven si el título comienza con el argumento `title`.
Aquí utilizamos la `util.transform.toDynamoDBFilterExpression` para crear automáticamente un filtro a partir de un objeto:
```
const filter = util.transform.toDynamoDBFilterExpression({
title: { beginsWith: 'far away' },
});
const request = {};
request.filter = JSON.parse(filter);
```
Esto genera el filtro siguiente:
```
{
"filter": {
"expression": "(begins_with(#title,:title_beginsWith))",
"expressionNames": { "#title": "title" },
"expressionValues": {
":title_beginsWith": { "S": "far away" }
}
}
}
```
# Expresiones de condición
Al mutar objetos en DynamoDB utilizando las operaciones de DynamoDB `PutItem`, `UpdateItem` y `DeleteItem`, puede especificar opcionalmente una expresión de condición 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.
La función AWS AppSync DynamoDB permite especificar una expresión de condición `PutItem` en los objetos de solicitud `DeleteItem` y`UpdateItem`, además, una estrategia a seguir si la condición falla y el objeto no se ha actualizado.
## Ejemplo 1
El siguiente objeto de solicitud `PutItem` no tiene una expresión de condición. Como resultado, pone un elemento en DynamoDB incluso si ya existe un elemento con la misma clave, lo que permite sobrescribir el elemento existente.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
};
}
```
## Ejemplo 2
El siguiente objeto `PutItem` tiene una expresión de condición que permitirá que la operación se complete solo si *no* existe un elemento con la misma clave en DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { foo, bar, ...values} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues(values),
condition: { expression: "attribute_not_exists(id)" }
};
}
```
De forma predeterminada, si se produce un error en la comprobación de la condición, la función AWS AppSync DynamoDB proporciona un error para la mutación.
Sin embargo, la función AWS AppSync DynamoDB ofrece algunas funciones adicionales para ayudar a los desarrolladores a gestionar algunos casos extremos comunes:
+ Si las funciones de AWS AppSync DynamoDB pueden determinar que el valor actual de DynamoDB coincide con el resultado deseado, tratarán la operación como si se hubiera realizado correctamente de todos modos.
+ En lugar de devolver un error, puede configurar la función para que invoque una función Lambda personalizada para decidir cómo debe gestionar el error la función de AWS AppSync DynamoDB.
Estos casos se describen con más detalle en la sección de [gestión de un error de comprobación de la condición](#condition-check).
[Para obtener más información sobre las expresiones de condiciones de DynamoDB, consulte la documentación de DynamoDB. ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)
## Especificación de una condición
Todos los objetos de solicitud `PutItem`, `UpdateItem` y `DeleteItem` permiten especificar una sección `condition` opcional. Si se omite, no se comprobará ninguna condición. Si se especifica, la condición debe ser true para que la operación se lleve a cabo correctamente.
Las secciones `condition` tienen la siguiente estructura:
```
type ConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string};
expressionValues?: { [key: string]: any};
equalsIgnore?: string[];
consistentRead?: boolean;
conditionalCheckFailedHandler?: {
strategy: 'Custom' | 'Reject';
lambdaArn?: string;
};
};
```
Los campos siguientes especifican la condición:
** `expression` **
La misma expresión de actualización. Para obtener más información sobre cómo escribir expresiones de condiciones, consulte la documentación de [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Este campo debe especificarse.
** `expressionNames` **
Las sustituciones de los marcadores de posición de nombre de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre usado en la *expresión*, y el valor tiene que ser una cadena que corresponda al nombre de atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de nombre de atributo de expresión que se usen en la *expresión*.
** `expressionValues` **
Las sustituciones de los marcadores de posición de valor de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la expresión y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor debe especificarse. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la expresión.
Los campos restantes indican a la función AWS AppSync DynamoDB cómo gestionar un error de comprobación de condición:
** `equalsIgnore` **
Cuando se produce un error en una comprobación de estado al utilizar la `PutItem` operación, la función AWS AppSync DynamoDB compara el elemento que se encuentra actualmente en DynamoDB con el elemento que intentó escribir. Si son iguales, trata la operación como si se hubiera realizado correctamente. Puede usar el `equalsIgnore` campo para especificar una lista de atributos que AWS AppSync debe omitir al realizar la comparación. Por ejemplo, si la única diferencia ha sido un atributo `version`, trata la operación como si se hubiera realizado satisfactoriamente. Este campo es opcional.
** `consistentRead` **
Cuando se produce un error en una comprobación de estado, AWS AppSync obtiene el valor actual del elemento de DynamoDB mediante una lectura muy coherente. Puede usar este campo para indicar a la función AWS AppSync DynamoDB que utilice en su lugar una lectura eventualmente coherente. Este campo es opcional y de forma predeterminada es `true`.
** `conditionalCheckFailedHandler` **
En esta sección, puede especificar cómo trata la función AWS AppSync DynamoDB un error de comprobación de condición después de comparar el valor actual de DynamoDB con el resultado esperado. Esta sección es opcional. Si se omite, el valor predeterminado es una estrategia `Reject`.
** `strategy` **
La estrategia que adopta la función AWS AppSync DynamoDB después de comparar el valor actual de DynamoDB con el resultado esperado. Este campo es obligatorio y tiene los siguientes valores posibles:
** `Reject` **
Se produce un error en la mutación y se agrega un error a la respuesta de GraphQL.
** `Custom` **
La función AWS AppSync DynamoDB invoca una función Lambda personalizada para decidir cómo gestionar el error de comprobación de estado. Cuando `strategy` tiene el valor `Custom`, el campo `lambdaArn` debe contener el ARN de la función Lambda que se va a invocar.
** `lambdaArn` **
El ARN de la función Lambda que se va a invocar y que determina cómo debe gestionar la función de DynamoDB el error de comprobación de AWS AppSync condición. Este campo solo tiene que especificarse cuando `strategy` tiene el valor `Custom`. Para obtener más información acerca de cómo utilizar esta característica, consulte [Gestión de un error de comprobación de la condición](#condition-check).
## Gestión de un error de comprobación de la condición
Cuando se produce un error en una comprobación de condición, la función AWS AppSync DynamoDB puede transmitir el error de la mutación y el valor actual del objeto mediante la utilidad. `util.appendError` Sin embargo, la función AWS AppSync DynamoDB ofrece algunas funciones adicionales para ayudar a los desarrolladores a gestionar algunos casos extremos comunes:
+ Si las funciones de AWS AppSync DynamoDB pueden determinar que el valor actual de DynamoDB coincide con el resultado deseado, tratarán la operación como si se hubiera realizado correctamente de todos modos.
+ En lugar de devolver un error, puede configurar la función para que invoque una función Lambda personalizada para decidir cómo debe gestionar el error la función de AWS AppSync DynamoDB.
El diagrama de flujo de este proceso es:
![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/es_es/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)
### Comprobación del resultado deseado
Cuando se produce un error en la comprobación de estado, la función AWS AppSync DynamoDB ejecuta una solicitud de `GetItem` DynamoDB para obtener el valor actual del elemento de DynamoDB. De forma predeterminada, utiliza una lectura altamente coherente; sin embargo, esto puede configurarse mediante el campo `consistentRead` en el bloque `condition` y compararlo con el resultado esperado:
+ Para la `PutItem` operación, la función AWS AppSync DynamoDB compara el valor actual con el que intentó escribir, excluyendo todos los atributos incluidos `equalsIgnore` en la comparación. Si los elementos son los mismos, trata la operación como si se hubiera realizado y devuelve el elemento obtenido de DynamoDB. De lo contrario, sigue la estrategia configurada.
Por ejemplo, si el objeto de solicitud `PutItem` tenía el siguiente aspecto:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { id, name, version} = ctx.args
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({foo, bar}),
attributeValues: util.dynamodb.toMapValues({ name, version: version+1 }),
condition: {
expression: "version = :expectedVersion",
expressionValues: util.dynamodb.toMapValues({':expectedVersion': version}),
equalsIgnore: ['version']
}
};
}
```
Y el elemento que está actualmente en DynamoDB fuese de la siguiente manera:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
La función AWS AppSync DynamoDB compararía el elemento que intentaba escribir con el valor actual, comprobaría que la única diferencia era el campo, pero como está configurada para ignorar `version` el campo, considera que `version` la operación se ha realizado correctamente y devuelve el elemento que se ha recuperado de DynamoDB.
+ Para la `DeleteItem` operación, la función AWS AppSync DynamoDB comprueba si DynamoDB ha devuelto un elemento. Si no se devuelve ningún elemento, trata la operación como si se hubiera realizado correctamente. De lo contrario, sigue la estrategia configurada.
+ Para la `UpdateItem` operación, la función AWS AppSync DynamoDB no tiene suficiente información para determinar si el elemento que se encuentra actualmente en DynamoDB coincide con el resultado esperado y, por lo tanto, sigue la estrategia configurada.
Si el estado actual del objeto en DynamoDB es diferente del resultado esperado, la función AWS AppSync DynamoDB sigue la estrategia configurada: rechazar la mutación o invocar una función Lambda para determinar qué hacer a continuación.
### Aplicación de la estrategia de rechazo
Al seguir la `Reject` estrategia, la función AWS AppSync DynamoDB devuelve un error para la mutación.
Por ejemplo, si se recibe la solicitud de mutación siguiente:
```
mutation {
updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
Name
theVersion
}
}
```
Si el elemento devuelto de DynamoDB tiene un aspecto similar al siguiente:
```
{
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
}
```
Y el controlador de respuestas de función tiene el siguiente aspecto:
```
import { util } from '@aws-appsync/utils';
export function response(ctx) {
const { version, ...values } = ctx.result;
const result = { ...values, theVersion: version };
if (ctx.error) {
if (error) {
return util.appendError(error.message, error.type, result, null);
}
}
return result
}
```
La respuesta GraphQL tiene este aspecto:
```
{
"data": null,
"errors": [
{
"message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
"errorType": "DynamoDB:ConditionalCheckFailedException",
...
}
]
}
```
Además, si hay algún campo en el objeto devuelto que hayan cumplimentado otros solucionadores y si la mutación se ha efectuado satisfactoriamente, el objeto no se resuelve cuando se devuelve en la sección `error`.
### Aplicación de la estrategia personalizada
Al seguir la `Custom` estrategia, la función AWS AppSync DynamoDB invoca una función Lambda para decidir qué hacer a continuación. La función Lambda selecciona una de las siguientes opciones:
+ `reject` para la mutación. Esto indica a la función AWS AppSync DynamoDB que se comporte como si la estrategia configurada lo `Reject` fuera, devolviendo un error para la mutación y el valor actual del objeto en DynamoDB, tal y como se describe en la sección anterior.
+ `discard` para la mutación. Esto indica a la función AWS AppSync DynamoDB que ignore silenciosamente el error de comprobación de estado y devuelve el valor en DynamoDB.
+ `retry` para la mutación. Esto indica a la función AWS AppSync DynamoDB que vuelva a intentar la mutación con un nuevo objeto de solicitud.
**La solicitud de invocación Lambda**
La AWS AppSync función DynamoDB invoca la función Lambda especificada en. `lambdaArn` Se utiliza el mismo `service-role-arn` configurado en el origen de datos. La carga de la invocación tiene la siguiente estructura:
```
{
"arguments": { ... },
"requestMapping": {... },
"currentValue": { ... },
"resolver": { ... },
"identity": { ... }
}
```
Los campos se definen de la siguiente manera:
** `arguments` **
Los argumentos de la mutación de GraphQL. Esto es lo mismo que los argumentos disponibles en el objeto de solicitud en `context.arguments`.
** `requestMapping` **
El objeto de solicitud de esta operación.
** `currentValue` **
El valor actual del objeto en DynamoDB.
** `resolver` **
Información sobre el solucionador o la función AWS AppSync .
** `identity` **
Información sobre el intermediario. Equivale a la información de identidad disponible en el objeto de solicitud en `context.identity`.
Un ejemplo completo de la carga:
```
{
"arguments": {
"id": "1",
"name": "Steve",
"expectedVersion": 1
},
"requestMapping": {
"version" : "2017-02-28",
"operation" : "PutItem",
"key" : {
"id" : { "S" : "1" }
},
"attributeValues" : {
"name" : { "S" : "Steve" },
"version" : { "N" : 2 }
},
"condition" : {
"expression" : "version = :expectedVersion",
"expressionValues" : {
":expectedVersion" : { "N" : 1 }
},
"equalsIgnore": [ "version" ]
}
},
"currentValue": {
"id" : { "S" : "1" },
"name" : { "S" : "Steve" },
"version" : { "N" : 8 }
},
"resolver": {
"tableName": "People",
"awsRegion": "us-west-2",
"parentType": "Mutation",
"field": "updatePerson",
"outputType": "Person"
},
"identity": {
"accountId": "123456789012",
"sourceIp": "x.x.x.x",
"user": "AIDAAAAAAAAAAAAAAAAAA",
"userArn": "arn:aws:iam::123456789012:user/appsync"
}
}
```
**La respuesta de invocación Lambda**
La función Lambda puede inspeccionar la carga útil de invocación y aplicar cualquier lógica empresarial para decidir cómo debe gestionar el error la función de AWS AppSync DynamoDB. Existen tres opciones para gestionar el error de comprobación de condición:
+ `reject` para la mutación. La carga de respuesta de esta opción debe tener esta estructura:
```
{
"action": "reject"
}
```
Esto indica a la función AWS AppSync DynamoDB que se comporte como si la estrategia configurada lo `Reject` fuera, devolviendo un error para la mutación y el valor actual del objeto en DynamoDB, tal y como se describe en la sección anterior.
+ `discard` para la mutación. La carga de respuesta de esta opción debe tener esta estructura:
```
{
"action": "discard"
}
```
Esto indica a la función AWS AppSync DynamoDB que ignore silenciosamente el error de comprobación de estado y devuelve el valor en DynamoDB.
+ `retry` para la mutación. La carga de respuesta de esta opción debe tener esta estructura:
```
{
"action": "retry",
"retryMapping": { ... }
}
```
Esto indica a la función AWS AppSync DynamoDB que vuelva a intentar la mutación con un nuevo objeto de solicitud. La estructura de la sección `retryMapping` depende de la operación de DynamoDB y es un subconjunto del objeto de solicitud completo de esa operación.
Para `PutItem`, la sección `retryMapping` tiene la siguiente estructura. Para obtener una descripción del `attributeValues` campo, consulte. [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-putitem)
```
{
"attributeValues": { ... },
"condition": {
"equalsIgnore" = [ ... ],
"consistentRead" = true
}
}
```
Para `UpdateItem`, la sección `retryMapping` tiene la siguiente estructura. Para obtener una descripción de la `update` sección, consulte [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem).
```
{
"update" : {
"expression" : "someExpression"
"expressionNames" : {
"#foo" : "foo"
},
"expressionValues" : {
":bar" : ... typed value
}
},
"condition": {
"consistentRead" = true
}
}
```
Para `DeleteItem`, la sección `retryMapping` tiene la siguiente estructura.
```
{
"condition": {
"consistentRead" = true
}
}
```
No hay forma de especificar otra operación o clave en la que trabajar. La función AWS AppSync DynamoDB solo permite reintentos de la misma operación en el mismo objeto. Asimismo, la sección `condition` no permite especificar un `conditionalCheckFailedHandler`. Si se produce un error en el reintento, la AWS AppSync función DynamoDB sigue la estrategia. `Reject`
A continuación se muestra un ejemplo de función Lambda para tratar una solicitud `PutItem` sin éxito. La lógica de negocio examina quién realizó la llamada. Si la realizó `jeffTheAdmin`, vuelve a intentar realizar la solicitud, actualizando `version` y `expectedVersion` desde el elemento actualmente en DynamoDB. De lo contrario, rechaza la mutación.
```
exports.handler = (event, context, callback) => {
console.log("Event: "+ JSON.stringify(event));
// Business logic goes here.
var response;
if ( event.identity.user == "jeffTheAdmin" ) {
response = {
"action" : "retry",
"retryMapping" : {
"attributeValues" : event.requestMapping.attributeValues,
"condition" : {
"expression" : event.requestMapping.condition.expression,
"expressionValues" : event.requestMapping.condition.expressionValues
}
}
}
response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version
} else {
response = { "action" : "reject" }
}
console.log("Response: "+ JSON.stringify(response))
callback(null, response)
};
```
# Expresiones de condición de transacción
Las expresiones de condición de transacción están disponibles en las solicitudes de los cuatro tipos de operaciones en `TransactWriteItems`, a saber, `PutItem`, `DeleteItem`, `UpdateItem` y `ConditionCheck`.
Para `PutItem`, `DeleteItem` y `UpdateItem`, la expresión de condición de transacción es opcional. Para `ConditionCheck`, se requiere la expresión de condición de transacción.
## Ejemplo 1
El siguiente controlador de solicitudes de función `DeleteItem` de carácter transaccional no tiene una expresión de condición. Como resultado, elimina el elemento en DynamoDB.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId } = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
}
],
};
}
```
## Ejemplo 2
El siguiente controlador de solicitudes de función `DeleteItem` de carácter transaccional tiene una expresión de condición de transacción que permite que la operación tenga éxito únicamente si el autor de esa publicación es igual a un nombre determinado.
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { postId, authorName} = ctx.args;
return {
operation: 'TransactWriteItems',
transactItems: [
{
table: 'posts',
operation: 'DeleteItem',
key: util.dynamodb.toMapValues({ postId }),
condition: util.transform.toDynamoDBConditionExpression({
authorName: { eq: authorName },
}),
}
],
};
}
```
Si la comprobación de condición no se realiza correctamente, provocará la excepción `TransactionCanceledException` y se devolverá el detalle del error en `ctx.result.cancellationReasons`. Tenga en cuenta que, de forma predeterminada, el elemento anterior de DynamoDB que provocó el error en esa comprobación de condición se devolverá en `ctx.result.cancellationReasons`.
## Especificación de una condición
Todos los objetos de solicitud `PutItem`, `UpdateItem` y `DeleteItem` permiten especificar una sección `condition` opcional. Si se omite, no se comprobará ninguna condición. Si se especifica, la condición debe ser true para que la operación se lleve a cabo correctamente. `ConditionCheck` debe tener una sección `condition` sección para especificarla. La condición debe ser verdadera para que toda la transacción se realice correctamente.
Las secciones `condition` tienen la siguiente estructura:
```
type TransactConditionCheckExpression = {
expression: string;
expressionNames?: { [key: string]: string };
expressionValues?: { [key: string]: string };
returnValuesOnConditionCheckFailure: boolean;
};
```
Los campos siguientes especifican la condición:
** `expression` **
La misma expresión de actualización. Para obtener más información sobre cómo escribir expresiones de condiciones, consulte la documentación de [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Este campo debe especificarse.
** `expressionNames` **
Las sustituciones de los marcadores de posición de nombre de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre usado en la *expresión*, y el valor tiene que ser una cadena que corresponda al nombre de atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de nombre de atributo de expresión que se usen en la *expresión*.
** `expressionValues` **
Las sustituciones de los marcadores de posición de valor de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de valor usado en la expresión y el valor tiene que ser un valor con tipo. Para obtener más información sobre cómo especificar un “valor con tipo”, consulte [Sistema de tipos (mapeo de solicitud)](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-typed-values-request). Este valor debe especificarse. Este campo es opcional y solo debe rellenarse con las sustituciones de los marcadores de posición de valor de atributo de expresión que se usen en la expresión.
** `returnValuesOnConditionCheckFailure` **
Especifique si desea recuperar el elemento en DynamoDB cuando se produzca un error en la comprobación de condición. El elemento recuperado estará en `ctx.result.cancellationReasons[].item`, donde `` es el índice del elemento de solicitud que no ha superado la comprobación de condición. Este valor se establece de forma predeterminada en true.
# Proyecciones
Al leer objetos de DynamoDB mediante las operaciones `GetItem`, `Scan`, `Query`, `BatchGetItem` y `TransactGetItems`, tiene la posibilidad de especificar una proyección para identificar los atributos deseados. La propiedad de proyección tiene la siguiente estructura, que es similar a los filtros:
```
type DynamoDBExpression = {
expression: string;
expressionNames?: { [key: string]: string}
};
```
Los campos se definen de la siguiente manera:
** `expression` **
La expresión de proyección, que es una cadena. Para recuperar un solo atributo, especifique su nombre. Si desea obtener varios atributos, separe sus nombres mediante comas. Para obtener más información sobre la redacción de expresiones de proyección, consulte la documentación relativa a las [expresiones de proyección de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Este campo es obligatorio.
** `expressionNames` **
Las sustituciones de los marcadores de posición de *nombre* de atributo de expresión, en forma de pares de clave-valor. La clave corresponde a un marcador de posición de nombre utilizado en la `expression`. El valor debe ser una cadena que corresponda al nombre del atributo del elemento en DynamoDB. Este campo es opcional y solo debe rellenarse con las sustituciones de marcadores de posición de nombre de atributo de expresión que se usen en la `expression`. Para obtener más información acerca de `expressionNames`, consulte la [documentación de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html).
## Ejemplo 1
El siguiente ejemplo es una sección de proyección de una JavaScript función en la que DynamoDB devuelve únicamente `id` los atributos `author` y:
```
projection : {
expression : "#author, id",
expressionNames : {
"#author" : "author"
}
}
```
**sugerencia**
Puede acceder a su conjunto de selección de solicitudes de GraphQL utilizando. [selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html#aws-appsync-resolver-context-reference-info-js) Este campo permite enmarcar su expresión de proyección de forma dinámica según sus requisitos.
**nota**
Al utilizar expresiones de proyección con las operaciones `Query` y `Scan`, el valor de `select` debe ser `SPECIFIC_ATTRIBUTES`. Para obtener más información, consulte la [documentación de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).