Moduli incorporati - AWS AppSync
Funzioni del modulo DynamoDBFunzioni RDS del modulo Amazon

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Moduli incorporati

I moduli fanno parte del APPSYNC_JS runtime e forniscono utilità per aiutare a scrivere JavaScript resolver e funzioni.

Funzioni del modulo DynamoDB

Le funzioni del modulo DynamoDB offrono un'esperienza migliorata durante l'interazione con le fonti di dati DynamoDB. È possibile effettuare richieste verso le sorgenti dati DynamoDB utilizzando le funzioni e senza aggiungere la mappatura dei tipi.

I moduli vengono importati utilizzando: @aws-appsync/utils/dynamodb

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

Funzioni

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

InputPer informazioni su, vedere GetInput.

Genera un DynamoDBGetItemRequest oggetto per effettuare una GetItemrichiesta 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 oggetto per effettuare una PutItemrichiesta 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 oggetto per effettuare una DeleteItemrichiesta 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 una richiesta DynamoDBScanRequest di scansione per 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 DynamoDBSyncRequest oggetto per effettuare una richiesta di sincronizzazione. La richiesta riceve solo i dati modificati dall'ultima query (delta updates). Le richieste possono essere effettuate solo a sorgenti dati DynamoDB con versione.

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 oggetto per effettuare una UpdateItemrichiesta a DynamoDB.

Operazioni

Gli assistenti operativi consentono di eseguire azioni specifiche su parti dei dati durante gli aggiornamenti. Per iniziare, importa operations da@aws-appsync/utils/dynamodb:

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

Una funzione di supporto che aggiunge un nuovo elemento di attributo durante l'aggiornamento di DynamoDB.

Esempio

Per aggiungere un indirizzo (via, città e codice postale) a un elemento DynamoDB esistente utilizzando il valore 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)

Una funzione di supporto che aggiunge un payload all'elenco esistente in DynamoDB.

Esempio

Per aggiungere friend IDs (newFriendIds) appena aggiunto a una lista di amici esistente () durante un aggiornamento: friendsIds

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?)

Una funzione di supporto che decrementa il valore dell'attributo esistente nell'elemento durante l'aggiornamento di DynamoDB.

Esempio

Per diminuire di 10 il contatore di un amico (): friendsCount

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?)

Una funzione di supporto che incrementa il valore dell'attributo esistente nell'elemento durante l'aggiornamento di DynamoDB.

Esempio

Per incrementare il contatore di amici () di 10: friendsCount

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)

Una funzione di supporto che si aggiunge all'elenco esistente in DynamoDB.

Esempio

Per aggiungere friend IDs (newFriendIds) appena aggiunto a un elenco di amici esistente () durante un aggiornamento: friendsIds

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)

Una funzione di supporto che sostituisce un attributo esistente durante l'aggiornamento di un elemento in DynamoDB. È utile quando si desidera aggiornare l'intero oggetto o sottooggetto nell'attributo e non solo le chiavi nel payload.

Esempio

Per sostituire un indirizzo (via, città e codice postale) in un oggetto: 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)

Una funzione di supporto che sostituisce un elemento in un elenco.

Esempio

Nell'ambito di update (newFriendIds), questo esempio veniva utilizzato updateListItem per aggiornare i valori ID del secondo elemento (index:1, new ID:102) e del terzo elemento (index:2, new ID:112) in un elenco (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 });
}

Input

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

Dichiarazione del tipo

  • consistentRead?: boolean(opzionale)

    Un booleano opzionale per specificare se si desidera eseguire una lettura fortemente coerente con DynamoDB.

  • key: DynamoDBKey<T> (obbligatorio)

    Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento.

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

Dichiarazione del tipo

  • _version?: number(opzionale)

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

    Quando si inserisce un oggetto in una tabella DynamoDB, è possibile specificare facoltativamente un'espressione condizionale che controlli se la richiesta deve avere esito positivo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione.

  • customPartitionKey?: string(opzionale)

    Se abilitato, questo valore di stringa modifica il formato dei ds_pk record ds_sk and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della populateIndexFields voce.

  • item: Partial<T> (obbligatorio)

    Il resto degli attributi dell'elemento da inserire in DynamoDB.

  • key: DynamoDBKey<T> (obbligatorio)

    Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB su cui verrà eseguito il put. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento.

  • populateIndexFields?: boolean(opzionale)

    Un valore booleano che, se abilitato insieme acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne gsi_ds_pk andgsi_ds_sk. Per ulteriori informazioni, consulta Rilevamento e sincronizzazione dei conflitti nella Guida per gli AWS AppSync sviluppatori.

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

Dichiarazione del tipo

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

    Specifica una condizione chiave che descrive gli elementi da interrogare. Per un determinato indice, la condizione per una chiave di partizione deve essere un'uguaglianza e la chiave di ordinamento un confronto o un beginsWith (quando è una stringa). Per le chiavi di partizione e ordinamento sono supportati solo i tipi di numeri e stringhe.

    Esempio

    Prendi il User tipo seguente:

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

    La query può includere solo i seguenti campi: idname, eage:

    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; 
}

Dichiarazione di tipo

  • _version?: number(opzionale)

  • condition?: DynamoDBFilterObject<T>(opzionale)

    Quando rimuovi un oggetto in DynamoDB, puoi facoltativamente specificare un'espressione condizionale che controlli se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione.

    Esempio

    L'esempio seguente è un'DeleteItemespressione contenente una condizione che consente l'esito positivo dell'operazione solo se il proprietario del documento corrisponde all'utente che effettua la richiesta.

    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(opzionale)

    Se abilitato, il customPartitionKey valore modifica il formato dei ds_pk record ds_sk and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della populateIndexFields voce.

  • key: DynamoDBKey<T> (obbligatorio)

    Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB che viene rimosso. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento.

    Esempio

    Se a ha la chiave hash User solo con un utenteid, la chiave sarebbe simile a questa:

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

    Se l'utente della tabella ha una chiave hash (id) e una chiave di ordinamento (name), la chiave sarebbe simile a questa:

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

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

  • populateIndexFields?: boolean(opzionale)

    Un valore booleano che, se abilitato insieme acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne gsi_ds_pk andgsi_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; 
}

Dichiarazione del tipo

  • consistentRead?: boolean | null(opzionale)

    Un booleano opzionale per indicare letture coerenti quando si esegue una query su DynamoDB. Il valore predefinito è false.

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

    Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella.

  • index?: string | null(opzionale)

    Un nome opzionale dell'indice da scansionare.

  • limit?: number | null(opzionale)

    Un numero massimo opzionale di risultati da restituire.

  • nextToken?: string | null(opzionale)

    Un token di impaginazione opzionale per continuare una query precedente. dalla quale deve essere ottenuto.

  • scanIndexForward?: boolean | null(opzionale)

    Un booleano opzionale per indicare se l'interrogazione viene eseguita in ordine crescente o decrescente. Per impostazione predefinita, questo valore è impostato su true.

  • segment?: number(opzionale)

  • select?: DynamoDBSelectAttributes(opzionale)

    Attributi da restituire da DynamoDB. Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. I valori supportati sono:

    • ALL_ATTRIBUTES

      Restituisce tutti gli attributi degli elementi dalla tabella o dall'indice specificato. Se si esegue una query su un indice secondario locale, DynamoDB recupera l'intero elemento dalla tabella principale per ogni elemento corrispondente nell'indice. Se l'indice è configurato per proiettare tutti gli attributi della voce, è possibile ottenere tutti i dati dall'indice secondario locale, senza necessità di recupero.

    • ALL_PROJECTED_ATTRIBUTES

      Restituisce tutti gli attributi che sono stati proiettati nell'indice. Se la configurazione dell'indice prevede che vi siano proiettati tutti gli attributi, il valore che restituisce è uguale a quello dato da ALL_ATTRIBUTES.

    • SPECIFIC_ATTRIBUTES

      Restituisce solo gli attributi elencati inProjectionExpression. Questo valore restituito equivale a specificare ProjectionExpression senza specificare alcun valore per. AttributesToGet

  • totalSegments?: number(opzionale)

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

Dichiarazione del tipo

  • basePartitionKey?: string(opzionale)

    La chiave di partizione della tabella di base da utilizzare durante l'esecuzione di un'operazione di sincronizzazione. Questo campo consente di eseguire un'operazione di sincronizzazione quando la tabella utilizza una chiave di partizione personalizzata.

  • deltaIndexName?: string(opzionale)

    L'indice utilizzato per l'operazione di sincronizzazione. Questo indice è necessario per abilitare un'operazione di sincronizzazione sull'intera tabella delta store quando la tabella utilizza una chiave di partizione personalizzata. L'operazione di sincronizzazione verrà eseguita su GSI (creato su gsi_ds_pk andgsi_ds_sk).

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

    Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella.

  • lastSync?: number(opzionale)

    Il momento, in millisecondi di epoca, in cui è iniziata l'ultima operazione di sincronizzazione riuscita. Se specificato, vengono restituiti solo gli elementi che sono stati modificati dopo lastSync. Questo campo deve essere compilato solo dopo aver recuperato tutte le pagine da un'operazione di sincronizzazione iniziale. Se omesso, verranno restituiti i risultati della tabella di base. In caso contrario, verranno restituiti i risultati della tabella delta.

  • limit?: number | null(opzionale)

    Un numero massimo opzionale di elementi da valutare contemporaneamente. Se omesso, il limite predefinito sarà impostato su 100 elementi. Il valore massimo per questo campo è 1000 articoli.

  • nextToken?: string | null(opzionale)

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

Dichiarazione del tipo

  • _version?: number(opzionale)

  • condition?: DynamoDBFilterObject<T>(opzionale)

    Quando aggiorni un oggetto in DynamoDB, puoi facoltativamente specificare un'espressione condizionale che controlli se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione.

  • customPartitionKey?: string(opzionale)

    Se abilitato, il customPartitionKey valore modifica il formato dei ds_pk record ds_sk and utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione della populateIndexFields voce.

  • key: DynamoDBKey<T> (obbligatorio)

    Un parametro obbligatorio che specifica la chiave dell'elemento in DynamoDB che viene aggiornato. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento.

  • populateIndexFields?: boolean(opzionale)

    Un valore booleano che, se abilitato insieme acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne gsi_ds_pk andgsi_ds_sk.

  • update: DynamoDBUpdateObject<T>

    Un oggetto che specifica gli attributi da aggiornare insieme ai relativi nuovi valori. L'oggetto di aggiornamento può essere utilizzato conadd,remove,replace,increment,decrement, appendprepend,updateListItem.

Funzioni RDS del modulo Amazon

Le funzioni RDS del modulo Amazon offrono un'esperienza migliorata durante l'interazione con i database configurati con Amazon RDS DataAPI. Il modulo viene importato utilizzando@aws-appsync/utils/rds: 

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

Le funzioni possono essere importate anche singolarmente. Ad esempio, l'importazione seguente utilizzasql:

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

Funzioni

Puoi utilizzare gli aiutanti di utilità del AWS AppSync RDS modulo per interagire con il tuo database.

L'selectutilità crea un'SELECTistruzione per interrogare il database relazionale.

Uso di base

Nella sua forma base, puoi specificare la tabella su cui vuoi interrogare:

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

export function request(ctx) {

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

Nota che puoi anche specificare lo schema nell'identificatore della tabella:

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

export function request(ctx) {

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

Specificare le colonne

È possibile specificare le colonne con la columns proprietà. Se questo non è impostato su un valore, il valore predefinito è: *

export function request(ctx) {

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

Puoi anche specificare la tabella di una colonna:

export function request(ctx) {

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

Limiti e offset

Puoi applicare limit e offset alla query:

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
    }));
}

Ordina per

Puoi ordinare i risultati in base alla orderBy proprietà. Fornisci una matrice di oggetti che specificano la colonna e una dir proprietà opzionale:

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'}]
    }));
}

Filtri

Puoi creare filtri utilizzando l'oggetto di condizione speciale:

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'}}
    }));
}

Puoi anche combinare filtri:

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}}
    }));
}

Puoi anche creare OR dichiarazioni:

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 } }
        ]}
    }));
}

Puoi anche annullare una condizione connot:

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 } }
        ]}
    }));
}

È inoltre possibile utilizzare i seguenti operatori per confrontare i valori:

Operatore Descrizione Tipi di valori possibili
eq Uguale numero, stringa, booleano
uno Non uguale numero, stringa, booleano
le Minore di o uguale a numero, stringa
lt Minore di numero, stringa
età Maggiore di o uguale a numero, stringa
gt Maggiore di numero, stringa
contiene Piace string
notContains Non come string
beginsWith Inizia con il prefisso string
tra Tra due valori numero, stringa
attributeExists L'attributo non è nullo numero, stringa, booleano
formato controlla la lunghezza dell'elemento string

L'insertutilità fornisce un modo semplice per inserire elementi a riga singola nel database con l'operazione. INSERT

Inserimenti di singoli elementi

Per inserire un elemento, specifica la tabella e poi inserisci i valori dell'oggetto. Le chiavi degli oggetti vengono mappate alle colonne della tabella. I nomi delle colonne vengono espulsi automaticamente e i valori vengono inviati al database utilizzando la mappa variabile:

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)
}

Il mio caso SQL d'uso

Puoi combinare un insert seguito da select a per recuperare la riga inserita:

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 d'uso Postgres

Con Postgres, è possibile utilizzare returningper ottenere dati dalla riga inserita. Accetta * o una matrice di nomi di colonne:

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)
}

L'updateutilità consente di aggiornare le righe esistenti. È possibile utilizzare l'oggetto condizione per applicare modifiche alle colonne specificate in tutte le righe che soddisfano la condizione. Ad esempio, supponiamo di avere uno schema che ci consente di effettuare questa mutazione. Vogliamo aggiornare the name of Person con il id valore di3, ma solo se li conosciamo (known_since) dall'anno2000:

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

Il nostro risolutore di aggiornamenti ha questo aspetto:

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)
}

Possiamo aggiungere un segno di spunta alla nostra condizione per assicurarci che venga aggiornata solo la riga con la chiave primaria id uguale a3. Allo stesso modo, per Postgresinserts, è possibile utilizzare returning per restituire i dati modificati.

L'removeutilità consente di eliminare le righe esistenti. È possibile utilizzare l'oggetto condizione su tutte le righe che soddisfano la condizione. Nota che delete è una parola chiave riservata in JavaScript. removedovrebbe essere usato invece:

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)
}

Casting

In alcuni casi, potresti volere una maggiore specificità sul tipo di oggetto corretto da utilizzare nella tua dichiarazione. È possibile utilizzare i suggerimenti di tipo forniti per specificare il tipo di parametri. AWS AppSync supporta suggerimenti dello stesso tipo dei dati. API Puoi trasmettere i tuoi parametri utilizzando le typeHint funzioni del AWS AppSync rds modulo.

L'esempio seguente consente di inviare un array come valore che viene trasmesso come JSON oggetto. Utilizziamo l'->operatore per recuperare l'elemento index 2 in corrispondenza della matrice: JSON

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

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

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

Il casting è utile anche per la gestione e DATE il confronto TIME eTIMESTAMP:

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)
}

Ecco un altro esempio che mostra come inviare la data e l'ora correnti:

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)}`)
}

Suggerimenti di tipo disponibili

  • typeHint.DATE- Il parametro corrispondente viene inviato come oggetto del DATE tipo al database. Il formato accettato è YYYY-MM-DD.

  • typeHint.DECIMAL- Il parametro corrispondente viene inviato come oggetto del DECIMAL tipo al database.

  • typeHint.JSON- Il parametro corrispondente viene inviato come oggetto del JSON tipo al database.

  • typeHint.TIME- Il valore del parametro stringa corrispondente viene inviato come oggetto del TIME tipo al database. Il formato accettato è HH:MM:SS[.FFF].

  • typeHint.TIMESTAMP- Il valore del parametro stringa corrispondente viene inviato come oggetto del TIMESTAMP tipo al database. Il formato accettato è YYYY-MM-DD HH:MM:SS[.FFF].

  • typeHint.UUID- Il valore del parametro stringa corrispondente viene inviato come oggetto del UUID tipo al database.