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à.
Built-in moduli
I moduli fanno parte del APPSYNC_JS runtime e forniscono utilità per aiutare a scrivere JavaScript resolver e funzioni. Per esempi ed esempi, consulta il repository aws-appsync-resolver-samples. https://github.com/aws-samples/aws-appsync-resolver-samples
Funzioni del modulo DynamoDB
Le funzioni del modulo DynamoDB forniscono un'esperienza migliorata nell'interazione con le fonti di dati DynamoDB. Puoi effettuare richieste alle tue origini 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/dynamodbimport * as ddb from '@aws-appsync/utils/dynamodb';
Funzioni
-
get<T>(payload: GetInput): DynamoDBGetItemRequest -
Suggerimento
InputPer informazioni su, vedere GetInput.
Genera un
DynamoDBGetItemRequestoggetto per effettuare una GetItem richiesta 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
DynamoDBPutItemRequestoggetto per effettuare una PutItem richiesta 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
DynamoDBDeleteItemRequestoggetto per effettuare una DeleteItem richiesta 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 di scansione
DynamoDBScanRequestper effettuare una richiesta di scansione 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
DynamoDBSyncRequestoggetto per effettuare una richiesta di sincronizzazione. La richiesta riceve solo i dati modificati dall'ultima query (aggiornamenti delta). Le richieste possono essere effettuate solo a origini 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
DynamoDBUpdateItemRequestoggetto per effettuare una UpdateItem richiesta a DynamoDB.
Operazioni
Gli aiutanti 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 operationsimport {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 gli ID amici appena aggiunti (
newFriendIds) a una lista di amici esistente () durante un aggiornamento:friendsIdsimport { 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 il contatore () di un amico di 10:
friendsCountimport { 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 un amico () di 10:
friendsCountimport { 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 gli ID amici appena aggiunti () a una lista di amici esistente (
newFriendIds) durante un aggiornamento:friendsIdsimport { 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. Ciò è 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:
infoimport { 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 utilizzatoupdateListItemper 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(facoltativo)Un valore 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 di tipo
-
_version?: number(facoltativo) -
condition?: DynamoDBFilterObject<T> | null(facoltativo)Quando si inserisce un oggetto in una tabella DynamoDB, è possibile specificare facoltativamente un'espressione condizionale che controlla se la richiesta deve essere completata o meno in base allo stato dell'oggetto già presente in DynamoDB prima dell'esecuzione dell'operazione.
-
customPartitionKey?: string(facoltativo)Se abilitato, questo valore di stringa modifica il formato dei
ds_pkrecordds_ske utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione dellapopulateIndexFieldsvoce. -
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 l'inserimento. Gli elementi DynamoDB possono avere una sola chiave hash o chiavi di hash e ordinamento.
-
populateIndexFields?: boolean(facoltativo)Un valore booleano che, se abilitato insieme a
customPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne e.gsi_ds_pkgsi_ds_skPer 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 si tratta di una stringa). Per le chiavi di partizione e ordinamento sono supportati solo i tipi di numeri e stringhe.Esempio
Prendi il
Usertipo qui sotto: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(facoltativo) -
condition?: DynamoDBFilterObject<T>(facoltativo)Quando rimuovi un oggetto in DynamoDB, puoi facoltativamente specificare un'espressione condizionale che controlla se la richiesta deve avere successo o meno in base allo stato dell'oggetto già presente in DynamoDB prima dell'esecuzione dell'operazione.
Esempio
L'esempio seguente è un'
DeleteItemespressione contenente una condizione che consente il successo 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(facoltativo)Se abilitato, il
customPartitionKeyvalore modifica il formato deids_pkrecordds_ske utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione dellapopulateIndexFieldsvoce. -
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
Usersolo la chiave hash di un utenteid, la chiave sarà 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 sarà 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(facoltativo)Un valore booleano che, se abilitato insieme a
customPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nellegsi_ds_pkcolonne e.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; }Dichiarazione di tipo
-
consistentRead?: boolean | null(facoltativo)Un valore booleano opzionale per indicare letture coerenti durante l'interrogazione di DynamoDB. Il valore predefinito è
false. -
filter?: DynamoDBFilterObject<T> | null(facoltativo)Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella.
-
index?: string | null(facoltativo)Un nome opzionale dell'indice da scansionare.
-
limit?: number | null(facoltativo)Un numero massimo opzionale di risultati da restituire.
-
nextToken?: string | null(facoltativo)Un token di impaginazione opzionale per continuare una query precedente. dalla quale deve essere ottenuto.
-
scanIndexForward?: boolean | null(facoltativo)Un valore booleano opzionale per indicare se l'interrogazione viene eseguita in ordine crescente o decrescente. Per impostazione predefinita, questo valore è impostato su
true. -
segment?: number(facoltativo) -
select?: DynamoDBSelectAttributes(facoltativo)Attributi da restituire da DynamoDB. Per impostazione predefinita, il resolver AWS AppSync DynamoDB restituisce solo gli attributi proiettati nell'indice. I valori supportati sono:
-
ALL_ATTRIBUTESRestituisce tutti gli attributi degli elementi dalla tabella o dall'indice specificato. Se si interroga 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_ATTRIBUTESRestituisce 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_ATTRIBUTESRestituisce solo gli attributi elencati in
ProjectionExpression. Questo valore restituito equivale a specificareProjectionExpressionsenza specificare alcun valore per.AttributesToGet
-
-
totalSegments?: number(facoltativo)
-
Type DynamoDBSyncInput<T>-
DynamoDBSyncInput<T>: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject<T> | null; lastSync?: number; limit?: number | null; nextToken?: string | null; }Dichiarazione di tipo
-
basePartitionKey?: string(facoltativo)La chiave di partizione della tabella di base da utilizzare quando si esegue un'operazione di sincronizzazione. Questo campo consente di eseguire un'operazione di sincronizzazione quando la tabella utilizza una chiave di partizione personalizzata.
-
deltaIndexName?: string(facoltativo)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 sul GSI (creato su
gsi_ds_pkegsi_ds_sk). -
filter?: DynamoDBFilterObject<T> | null(facoltativo)Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella.
-
lastSync?: number(facoltativo)Il momento, in millisecondi epocali, 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. Altrimenti, verranno restituiti i risultati della tabella delta. -
limit?: number | null(facoltativo)Un numero massimo opzionale di elementi da valutare contemporaneamente. Se omesso, il limite predefinito sarà impostato su
100elementi. Il valore massimo per questo campo è1000articoli. -
nextToken?: string | null(facoltativo)
-
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(facoltativo) -
condition?: DynamoDBFilterObject<T>(facoltativo)Quando si aggiorna un oggetto in DynamoDB, è possibile specificare facoltativamente un'espressione condizionale che controlla se la richiesta deve avere esito positivo o meno in base allo stato dell'oggetto già presente in DynamoDB prima dell'esecuzione dell'operazione.
-
customPartitionKey?: string(facoltativo)Se abilitato, il
customPartitionKeyvalore modifica il formatods_ske ids_pkrecord utilizzati dalla tabella delta sync quando il controllo delle versioni è abilitato. Se abilitata, è abilitata anche l'elaborazione dellapopulateIndexFieldsvoce. -
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(facoltativo)Un valore booleano che, se abilitato insieme a
customPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne e.gsi_ds_pkgsi_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 con
add,remove,replace,increment,decrement,appendprepend,updateListItem.
-
Funzioni del modulo Amazon RDS
Le funzioni del modulo Amazon RDS forniscono un'esperienza migliorata durante l'interazione con i database configurati con l'API Amazon RDS Data. 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 helper di utilità del modulo AWS AppSync RDS per interagire con il tuo database.
L'selectutilità crea una SELECT dichiarazione 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 tua 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 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
È possibile applicare limit e offset alla richiesta:
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 con la orderBy proprietà. Fornisci una serie 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
È possibile creare filtri utilizzando l'oggetto condizionale 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 | Description | Tipi di valori possibili |
|---|---|---|
| eq | Uguale | numero, stringa, booleano |
| uno | Non uguale | numero, stringa, booleano |
| le | Minore di o uguale a | numero, stringa |
| lt | Less than | numero, stringa |
| età | Maggiore di o uguale a | numero, stringa |
| gt | Greater than | numero, stringa |
| contiene | Mi piace | stringa |
| NON contiene | Non mi piace | stringa |
| Inizia con | Inizia con il prefisso | stringa |
| tra | Tra due valori | numero, stringa |
| L'attributo esiste | L'attributo non è nullo | numero, stringa, booleano |
| formato | controlla la lunghezza dell'elemento | stringa |
L'insertutilità fornisce un modo semplice per inserire elementi a riga singola nel database con l'operazione. INSERT
Inserimenti di elementi singoli
Per inserire un elemento, specifica la tabella e quindi trasmetti il tuo oggetto di valori. Le chiavi dell'oggetto sono mappate alle colonne della tabella. I nomi delle colonne vengono eliminati automaticamente e i valori vengono inviati al database utilizzando la mappa delle variabili:
import { insert, createMySQLStatement } from '@aws-appsync/utils/rds'; export function request(ctx) { const { input: values } = ctx.args; const insertStatement = insert({ table: 'persons', values }); // Generates statement: // INSERT INTO `persons`(`name`) // VALUES(:NAME) return createMySQLStatement(insertStatement) }
Caso d'uso MySQL
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 di Postgres
Con Postgres, puoi utilizzarlo returning* o un array 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 le modifiche alle colonne specificate in tutte le righe che soddisfano la condizione. Ad esempio, supponiamo di avere uno schema che ci consenta di effettuare questa mutazione. Vogliamo aggiornare name of Person con il id valore di 3 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 il seguente 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 controllo alla nostra condizione per assicurarci che venga aggiornata solo la riga con la chiave primaria id uguale a3. Allo stesso modo, per Postgresinserts, puoi 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 gli stessi suggerimenti di tipo dell'API Data. 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 convertito come oggetto JSON. Usiamo l'->operatore per recuperare l'elemento index 2 nell'array 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 il confronto DATE eTIME: 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) }
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 sui tipi disponibili
-
typeHint.DATE- Il parametro corrispondente viene inviato come oggetto delDATEtipo al database. Il formato accettato èYYYY-MM-DD. -
typeHint.DECIMAL- Il parametro corrispondente viene inviato come oggetto delDECIMALtipo al database. -
typeHint.JSON- Il parametro corrispondente viene inviato come oggetto delJSONtipo al database. -
typeHint.TIME- Il valore del parametro stringa corrispondente viene inviato come oggetto delTIMEtipo al database. Il formato accettato èHH:MM:SS[.FFF]. -
typeHint.TIMESTAMP- Il valore del parametro stringa corrispondente viene inviato come oggetto delTIMESTAMPtipo al database. Il formato accettato èYYYY-MM-DD HH:MM:SS[.FFF]. -
typeHint.UUID- Il valore del parametro stringa corrispondente viene inviato come oggetto delUUIDtipo al database.