Módulos integrados - AWS AppSync
Funciones del módulo de DynamoDBFunciones RDS del módulo Amazon

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.

Módulos integrados

Los módulos son parte del APPSYNC_JS tiempo de ejecución y proporcionan utilidades para ayudar a escribir JavaScript resoluciones y funciones.

Funciones del módulo de DynamoDB

Las funciones del módulo de DynamoDB proporcionan una experiencia mejorada al interactuar con los orígenes de datos de DynamoDB. Puede realizar solicitudes a sus orígenes de datos de DynamoDB mediante las funciones y sin añadir asignación de tipos.

Los módulos se importan mediante @aws-appsync/utils/dynamodb:

// Modules are imported using @aws-appsync/utils/dynamodb
import * as ddb from '@aws-appsync/utils/dynamodb';

Funciones

get<T>(payload: GetInput): DynamoDBGetItemRequest
sugerencia

Consulte Entradas para obtener información acerca de GetInput.

Genera un DynamoDBGetItemRequest objeto para realizar una GetItemsolicitud a DynamoDB.

import { get } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return get({ key: { id: ctx.args.id } });
}
put<T>(payload): DynamoDBPutItemRequest

Genera un DynamoDBPutItemRequest objeto para realizar una PutItemsolicitud a DynamoDB.

import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	return ddb.put({ key: { id: util.autoId() }, item: ctx.args });
}
remove<T>(payload): DynamoDBDeleteItemRequest

Genera un DynamoDBDeleteItemRequest objeto para realizar una DeleteItemsolicitud a DynamoDB.

import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	return ddb.remove({ key: { id: ctx.args.id } });
}
scan<T>(payload): DynamoDBScanRequest

Genera un objeto DynamoDBScanRequest para realizar una solicitud Scan a DynamoDB.

import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken } = ctx.args;
	return ddb.scan({ limit, nextToken });
}
sync<T>(payload): DynamoDBSyncRequest

Genera un objeto DynamoDBSyncRequest para realizar una solicitud Sync. La solicitud solo recibe los datos modificados desde la última consulta (actualizaciones delta). Las solicitudes solo se pueden realizar a orígenes de datos de DynamoDB con control de versiones.

import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const { limit = 10, nextToken, lastSync } = ctx.args;
	return ddb.sync({ limit, nextToken, lastSync });
}
update<T>(payload): DynamoDBUpdateItemRequest

Genera un DynamoDBUpdateItemRequest objeto para realizar una UpdateItemsolicitud a DynamoDB.

Operaciones

Las aplicaciones auxiliares de operación permiten realizar acciones específicas en partes de sus datos durante las actualizaciones. Para empezar, importe operations desde @aws-appsync/utils/dynamodb:

// Modules are imported using operations
import {operations} from '@aws-appsync/utils/dynamodb';
add<T>(payload)

Función auxiliar que añade un nuevo elemento de atributo al actualizar DynamoDB.

Ejemplo

Para añadir una dirección (calle, ciudad y código postal) a un elemento de DynamoDB existente mediante el valor de ID:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		address: operations.add({
			street1: '123 Main St',
			city: 'New York',
			zip: '10001',
		}),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
append <T>(payload)

Función auxiliar que añade una carga a la lista existente en DynamoDB.

Ejemplo

Para añadir un amigo IDs (newFriendIds) recién agregado a una lista de amigos existente (friendsIds) durante una actualización:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.append(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
decrement (by?)

Función auxiliar que reduce el valor del atributo existente en el elemento al actualizar DynamoDB.

Ejemplo

Para reducir un contador de amigos (friendsCount) en 10:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.decrement(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
increment (by?)

Función auxiliar que incrementa el valor del atributo existente en el elemento al actualizar DynamoDB.

Ejemplo

Para incrementar un contador de amigos (friendsCount) en 10:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		friendsCount: operations.increment(10),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
prepend <T>(payload)

Función auxiliar que se antepone a la lista existente en DynamoDB.

Ejemplo

Para añadir un amigo IDs (newFriendIds) recién añadido a una lista de amigos existente (friendsIds) durante una actualización:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [101, 104, 111];
	const updateObj = {
		friendsIds: operations.prepend(newFriendIds),
	};
	return update({ key: { id: 1 }, update: updateObj });
}
replace <T>(payload)

Función auxiliar que sustituye un atributo existente al actualizar un elemento en DynamoDB. Esto resulta útil cuando se desea actualizar todo el objeto o subobjeto en el atributo y no solo las claves en la carga.

Ejemplo

Para sustituir una dirección (calle, ciudad y código postal) en un objeto info:

import { update, operations } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const updateObj = {
		info: {
			address: operations.replace({
				street1: '123 Main St',
				city: 'New York',
				zip: '10001',
			}),
		},
	};
	return update({ key: { id: 1 }, update: updateObj });
}
updateListItem <T>(payload, index)

Función auxiliar que sustituye un elemento en una lista.

Ejemplo

En el ámbito de la actualización (newFriendIds), en este ejemplo se utiliza updateListItem para actualizar los valores de ID del segundo elemento (índice: 1, nuevo ID: 102) y del tercer elemento (índice: 2, nuevo ID: 112) en una lista (friendsIds).

import { update, operations as ops } from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
	const newFriendIds = [
		ops.updateListItem('102', 1), ops.updateListItem('112', 2)
	];
	const updateObj = { friendsIds: newFriendIds };
	return update({ key: { id: 1 }, update: updateObj });
}

Entradas

Type GetInput<T>
GetInput<T>: { 
    consistentRead?: boolean; 
    key: DynamoDBKey<T>; 
}

Declaración de tipo

  • consistentRead?: boolean (opcional)

    Valor booleano opcional para especificar si desea realizar una lectura altamente coherente con DynamoDB.

  • key: DynamoDBKey<T> (obligatorio)

    Parámetro obligatorio que especifica la clave del elemento en DynamoDB. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.

Type PutInput<T>
PutInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T> | null; 
    customPartitionKey?: string; 
    item: Partial<T>; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}

Declaración de tipo

  • _version?: number (opcional)

  • condition?: DynamoDBFilterObject<T> | null (opcional)

    Al colocar un objeto en una tabla de DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.

  • customPartitionKey?: string (opcional)

    Cuando se habilita, este valor de cadena modifica el formato de los registros ds_sk y ds_pk que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada populateIndexFields.

  • item: Partial<T> (obligatorio)

    El resto de los atributos del elemento que deben incluirse en DynamoDB.

  • key: DynamoDBKey<T> (obligatorio)

    Parámetro obligatorio que especifica la clave del elemento en DynamoDB donde se realizará la operación put. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.

  • populateIndexFields?: boolean (opcional)

    Valor booleano que, cuando se habilita junto con la customPartitionKey, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas gsi_ds_pk y gsi_ds_sk. Para obtener más información, consulte el artículo sobre detección de conflictos y sincronización en la Guía para desarrolladores de AWS AppSync .

Type QueryInput<T>
QueryInput<T>: ScanInput<T> & { 
    query: DynamoDBKeyCondition<Required<T>>; 
}

Declaración de tipo

  • query: DynamoDBKeyCondition<Required<T>> (obligatorio)

    Especifica una condición clave que describe los elementos que se van a consultar. Para un índice determinado, la condición de una clave de partición debe ser una igualdad y la clave de ordenación una comparación o un elemento beginsWith (cuando es una cadena). Solo se admiten los tipos Number y String para las claves de partición y ordenación.

    Ejemplo

    Tome el tipo User a continuación:

    type User = {
  id: string;
  name: string;
  age: number;
  isVerified: boolean;
  friendsIds: string[] 
}

    La consulta solo puede incluir los campos siguientes: id, name y age:

    const query: QueryInput<User> = {
    name: { eq: 'John' },
    age: { gt: 20 },
}
Type RemoveInput<T>
RemoveInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
}

Declaración de tipo

  • _version?: number (opcional)

  • condition?: DynamoDBFilterObject<T> (opcional)

    Al quitar un objeto en DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.

    Ejemplo

    El siguiente ejemplo es una expresión DeleteItem que contiene una condición que permite que la operación se realice correctamente solo si el propietario del documento coincide con el usuario que realiza la solicitud.

    type Task = {
  id: string;
  title: string;
  description: string;
  owner: string;
  isComplete: boolean;
}
const condition: DynamoDBFilterObject<Task> = {
  owner: { eq: 'XXXXXXXXXXXXXXXX' },
}

remove<Task>({
   key: {
     id: 'XXXXXXXXXXXXXXXX',
  },
  condition,
});

  • customPartitionKey?: string (opcional)

    Cuando se habilita, el valor customPartitionKey modifica el formato de los registros ds_sk y ds_pk que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada populateIndexFields.

  • key: DynamoDBKey<T> (obligatorio)

    Parámetro obligatorio que especifica la clave del elemento de DynamoDB que se va a quitar. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.

    Ejemplo

    Si un User solo tiene la clave hash con un id de usuario, la clave tendría el siguiente aspecto:

    type User = {
	id: number
	name: string
	age: number
	isVerified: boolean
}
const key: DynamoDBKey<User> = {
	id: 1,
}

    Si el usuario de la tabla tiene una clave hash (id) y una clave de ordenación (name), la clave tendría el siguiente aspecto:

    type User = {
	id: number
	name: string
	age: number
	isVerified: boolean
	friendsIds: string[]
}

const key: DynamoDBKey<User> = {
	id: 1,
	name: 'XXXXXXXXXX',
}

  • populateIndexFields?: boolean (opcional)

    Valor booleano que, cuando se habilita junto con la customPartitionKey, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas gsi_ds_pk y gsi_ds_sk.

Type ScanInput<T>
ScanInput<T>: { 
    consistentRead?: boolean | null; 
    filter?: DynamoDBFilterObject<T> | null; 
    index?: string | null; 
    limit?: number | null; 
    nextToken?: string | null; 
    scanIndexForward?: boolean | null; 
    segment?: number; 
    select?: DynamoDBSelectAttributes; 
    totalSegments?: number; 
}

Declaración de tipo

  • consistentRead?: boolean | null (opcional)

    Valor booleano opcional para indicar lecturas coherentes al consultar DynamoDB. El valor predeterminado es false.

  • filter?: DynamoDBFilterObject<T> | null (opcional)

    Filtro opcional para aplicar a los resultados después de recuperarlos de la tabla.

  • index?: string | null (opcional)

    Nombre opcional del índice a examinar.

  • limit?: number | null (opcional)

    Número máximo opcional de resultados a devolver.

  • nextToken?: string | null (opcional)

    Token de paginación opcional para continuar una consulta anterior. Se debe obtener de una consulta anterior.

  • scanIndexForward?: boolean | null (opcional)

    Valor booleano opcional para indicar si la consulta se realiza en orden ascendente o descendente. De forma predeterminada, este valor se establece en true.

  • segment?: number (opcional)

  • select?: DynamoDBSelectAttributes (opcional)

    Atributos que se devolverán de DynamoDB. De forma predeterminada, el solucionador de AWS AppSync DynamoDB solo devuelve los atributos que se proyectan en el índice. Los valores admitidos son:

    • ALL_ATTRIBUTES

      Devuelve todos los atributos de elementos de la tabla o el índice especificados. Si consulta un índice secundario local, DynamoDB recupera todo el elemento de la tabla principal para cada elemento coincidente en el índice. Si el índice está configurado para proyectar todos los atributos de los elementos, todos los datos se pueden obtener del índice secundario local y no es necesario efectuar una recuperación.

    • ALL_PROJECTED_ATTRIBUTES

      Devuelve todos los atributos que se han proyectado en el índice. Si el índice está configurado para proyectar todos los atributos, este valor de retorno equivale a especificar ALL_ATTRIBUTES.

    • SPECIFIC_ATTRIBUTES

      Devuelve solo los atributos que aparecen en ProjectionExpression. Este valor devuelto equivale a especificar ProjectionExpression sin especificar ningún valor para AttributesToGet.

  • totalSegments?: number (opcional)

Type DynamoDBSyncInput<T>
DynamoDBSyncInput<T>: { 
    basePartitionKey?: string; 
    deltaIndexName?: string; 
    filter?: DynamoDBFilterObject<T> | null; 
    lastSync?: number; 
    limit?: number | null; 
    nextToken?: string | null; 
}

Declaración de tipo

  • basePartitionKey?: string (opcional)

    Clave de partición de la tabla base que se utilizará al realizar una operación Sync. Este campo permite realizar una operación Sync cuando la tabla utiliza una clave de partición personalizada.

  • deltaIndexName?: string (opcional)

    Índice utilizado para la operación Sync. Este índice es necesario para habilitar una operación Sync en toda la tabla de almacenamiento Delta cuando la tabla utiliza una clave de partición personalizada. La operación de sincronización se realizará en el GSI (creado en gsi_ds_pk ygsi_ds_sk).

  • filter?: DynamoDBFilterObject<T> | null (opcional)

    Filtro opcional para aplicar a los resultados después de recuperarlos de la tabla.

  • lastSync?: number (opcional)

    Momento, en milisegundos transcurridos desde la fecha de inicio, en el que comenzó la última operación Sync que se ha realizado correctamente. Si se especifica, solo se devuelven los elementos que han cambiado después de lastSync. Este campo solo debe rellenarse después de haber recuperado todas las páginas de una operación Sync inicial. Si se omite, se devolverán los resultados de la tabla base. De lo contrario, se devolverán los resultados de la tabla Delta.

  • limit?: number | null (opcional)

    Número máximo opcional de elementos que se evalúan en una sola vez. Si se omite, el límite predeterminado se establecerá en 100 elementos. El valor máximo de este campo son 1000 elementos.

  • nextToken?: string | null (opcional)

Type DynamoDBUpdateInput<T>
DynamoDBUpdateInput<T>: { 
    _version?: number; 
    condition?: DynamoDBFilterObject<T>; 
    customPartitionKey?: string; 
    key: DynamoDBKey<T>; 
    populateIndexFields?: boolean; 
    update: DynamoDBUpdateObject<T>; 
}

Declaración de tipo

  • _version?: number (opcional)

  • condition?: DynamoDBFilterObject<T> (opcional)

    Al actualizar un objeto en DynamoDB, puede especificar opcionalmente una expresión condicional que determine si la solicitud se debe atender o no en función del estado del objeto que ya está en DynamoDB antes de ejecutar la operación.

  • customPartitionKey?: string (opcional)

    Cuando se habilita, el valor customPartitionKey modifica el formato de los registros ds_sk y ds_pk que utiliza la tabla Delta Sync una vez habilitado el control de versiones. Cuando se habilita, también lo hace el procesamiento de la entrada populateIndexFields.

  • key: DynamoDBKey<T> (obligatorio)

    Parámetro obligatorio que especifica la clave del elemento de DynamoDB que se actualiza. Los elementos de DynamoDB pueden tener una sola clave hash o claves hash y de ordenación.

  • populateIndexFields?: boolean (opcional)

    Valor booleano que, cuando se habilita junto con la customPartitionKey, crea nuevas entradas para cada registro de la tabla Delta Sync, específicamente en las columnas gsi_ds_pk y gsi_ds_sk.

  • update: DynamoDBUpdateObject<T>

    Objeto que especifica los atributos que se van a actualizar junto con sus nuevos valores. El objeto de actualización se puede utilizar con add, remove, replace, increment, decrement, append, prepend y updateListItem.

Funciones RDS del módulo Amazon

Las funciones RDS del módulo de Amazon proporcionan una experiencia mejorada al interactuar con las bases de datos configuradas con Amazon RDS DataAPI. El módulo se importa mediante @aws-appsync/utils/rds: 

import * as rds from '@aws-appsync/utils/rds';

Las funciones también se pueden importar de forma individual. Por ejemplo, la importación siguiente utiliza sql:

import { sql } from '@aws-appsync/utils/rds';

Funciones

Puede utilizar las utilidades auxiliares del AWS AppSync RDS módulo para interactuar con su base de datos.

La utilidad select crea una instrucción SELECT para consultar la base de datos relacional.

Uso básico

En su forma básica, puede especificar la tabla que desea consultar:

import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement: 
    // "SELECT * FROM "persons"
    return createPgStatement(select({table: 'persons'}));
}

Tenga en cuenta que también puede especificar el esquema en el identificador de la tabla:

import { select, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {

    // Generates statement:
    // SELECT * FROM "private"."persons"
    return createPgStatement(select({table: 'private.persons'}));
}

Especificación de columnas

Puede especificar columnas con la propiedad columns. Si no se establece en un valor, el valor predeterminado es *:

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name']
    }));
}

También puede especificar la tabla de una columna:

export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "persons"."name"
    // FROM "persons"
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'persons.name']
    }));
}

Límites y desplazamientos

Puede aplicar limit y offset a la consulta:

export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name"
    // FROM "persons"
    // LIMIT :limit
    // OFFSET :offset
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        limit: 10,
        offset: 40
    }));
}

Ordenar por

Puede ordenar los resultados con la propiedad orderBy. Proporcione una matriz de objetos especificando la columna y una propiedad dir opcional:

export function request(ctx) {

    // Generates statement: 
    // SELECT "id", "name" FROM "persons"
    // ORDER BY "name", "id" DESC
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        orderBy: [{column: 'name'}, {column: 'id', dir: 'DESC'}]
    }));
}

Filtros

Puede crear filtros con el objeto de condición especial:

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}}
    }));
}

También puede combinar filtros:

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME and "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: {name: {eq: 'Stephane'}, id: {gt: 10}}
    }));
}

También puede crear instrucciones OR:

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE "name" = :NAME OR "id" > :ID
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { or: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}

También puede negar una condición con not:

export function request(ctx) {

    // Generates statement:
    // SELECT "id", "name"
    // FROM "persons"
    // WHERE NOT ("name" = :NAME AND "id" > :ID)
    return createPgStatement(select({
        table: 'persons',
        columns: ['id', 'name'],
        where: { not: [
            { name: { eq: 'Stephane'} },
            { id: { gt: 10 } }
        ]}
    }));
}

También puede utilizar los siguientes operadores para comparar valores:

Operador Descripción Tipos de valor posibles
eq Igualdad número, cadena, booleano
Uno Desigualdad número, cadena, booleano
una mentira Menor que o igual a número, cadena
lt Menor que número, cadena
edad Mayor que o igual a número, cadena
gt Mayor que número, cadena
contiene ¿Como cadena
notContains No como cadena
beginsWith Empieza con un prefijo cadena
entre Entre dos valores número, cadena
attributeExists El atributo no es nulo número, cadena, booleano
size comprueba la longitud del elemento cadena

La utilidad insert ofrece una forma sencilla de insertar elementos de una sola fila en la base de datos con la operación INSERT.

Inserciones de un solo elemento

Para insertar un elemento, especifique la tabla y, a continuación, transfiera su objeto de valores. Las claves de objetos se asignan a las columnas de la tabla. Los nombres de las columnas se escapan automáticamente y los valores se envían a la base de datos mediante el mapa de variables:

import { insert, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({ table: 'persons', values });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    return createMySQLStatement(insertStatement)
}

Mi caso SQL de uso

Puede combinar un insert seguido de un select para recuperar la fila insertada:

import { insert, select, createMySQLStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({  table: 'persons', values });
    const selectStatement = select({
        table: 'persons',
        columns: '*',
        where: { id: { eq: values.id } },
        limit: 1,
    });
    
    // Generates statement:
    // INSERT INTO `persons`(`name`)
    // VALUES(:NAME)
    // and
    // SELECT *
    // FROM `persons`
    // WHERE `id` = :ID
    return createMySQLStatement(insertStatement, selectStatement)
}

Caso de uso de Postgres

Con Postgres, puede usar returning para obtener datos de la fila que insertó. Acepta * o una matriz de nombres de columna:

import { insert, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: values } = ctx.args;
    const insertStatement = insert({
        table: 'persons',
        values,
        returning: '*'
    });

    // Generates statement:
    // INSERT INTO "persons"("name")
    // VALUES(:NAME)
    // RETURNING *
    return createPgStatement(insertStatement)
}

La utilidad update le permite actualizar las filas existentes. Puede utilizar el objeto de condición para aplicar cambios a las columnas especificadas en todas las filas que cumplan la condición. Por ejemplo, supongamos que tenemos un esquema que nos permite realizar esta mutación. Queremos actualizar el name de Person con el valor id de 3, pero solo si los conocemos (known_since) desde el año 2000:

mutation Update {
    updatePerson(
        input: {id: 3, name: "Jon"},
        condition: {known_since: {ge: "2000"}}
    ) {
    id
    name
  }
}

Nuestro solucionador de actualización tendrá este aspecto:

import { update, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id, ...values }, condition } = ctx.args;
    const where = {
        ...condition,
        id: { eq: id },
    };
    const updateStatement = update({
        table: 'persons',
        values,
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // UPDATE "persons"
    // SET "name" = :NAME, "birthday" = :BDAY, "country" = :COUNTRY
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}

Podemos añadir una comprobación a nuestra condición para asegurarnos de que solo se actualice la fila en la que la clave principal 3 sea igual a id. Del mismo modo, en el caso de inserts de Postgres, se puede utilizar returning para devolver los datos modificados.

La utilidad remove le permite eliminar las filas existentes. Puede utilizar el objeto de condición en todas las filas que cumplan la condición. Tenga en cuenta que delete es una palabra clave reservada en JavaScript. removedebería usarse en su lugar:

import { remove, createPgStatement } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const { input: { id }, condition } = ctx.args;
    const where = { ...condition, id: { eq: id } };
    const deleteStatement = remove({
        table: 'persons',
        where,
        returning: ['id', 'name'],
    });

    // Generates statement:
    // DELETE "persons"
    // WHERE "id" = :ID
    // RETURNING "id", "name"
    return createPgStatement(updateStatement)
}

Conversión

En algunos casos, es posible que desee más especificidad sobre el tipo de objeto correcto para usar en su instrucción. Puede utilizar las sugerencias de tipo proporcionadas para especificar el tipo de parámetros. AWS AppSync admite las mismas sugerencias de tipo que los datosAPI. Puede convertir sus parámetros utilizando las typeHint funciones del AWS AppSync rds módulo.

El siguiente ejemplo le permite enviar una matriz como un valor que se convierte en un JSON objeto. Usamos el -> operador para recuperar el elemento que se encuentra index 2 en la JSON matriz:

import { sql, createPgStatement, toJsonObject, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const arr = ctx.args.list_of_ids
    const statement = sql`select ${typeHint.JSON(arr)}->2 as value`
    return createPgStatement(statement)
}

export function response(ctx) {
    return toJsonObject(ctx.result)[0][0].value
}

La conversión también resulta útil al manipular y comparar DATE, TIME y TIMESTAMP:

import { select, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const when = ctx.args.when
    const statement = select({
        table: 'persons',
        where: { createdAt : { gt: typeHint.DATETIME(when) } }
    })
    return createPgStatement(statement)
}

Aquí se muestra otro ejemplo de cómo puede enviar la fecha y hora actuales:

import { sql, createPgStatement, typeHint } from '@aws-appsync/utils/rds';

export function request(ctx) {
    const now = util.time.nowFormatted('YYYY-MM-dd HH:mm:ss')
    return createPgStatement(sql`select ${typeHint.TIMESTAMP(now)}`)
}

Sugerencias de tipos disponibles

  • typeHint.DATE: el parámetro correspondiente se envía como un objeto de tipo DATE a la base de datos. El formato aceptado es YYYY-MM-DD.

  • typeHint.DECIMAL: el parámetro correspondiente se envía como un objeto de tipo DECIMAL a la base de datos.

  • typeHint.JSON: el parámetro correspondiente se envía como un objeto de tipo JSON a la base de datos.

  • typeHint.TIME: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo TIME a la base de datos. El formato aceptado es HH:MM:SS[.FFF].

  • typeHint.TIMESTAMP: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo TIMESTAMP a la base de datos. El formato aceptado es YYYY-MM-DD HH:MM:SS[.FFF].

  • typeHint.UUID: el valor del parámetro de cadena correspondiente se envía como un objeto de tipo UUID a la base de datos.