View a markdown version of this page

Built-in moduli - AWS AppSync GraphQL

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 GitHub

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/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 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 DynamoDBPutItemRequest oggetto 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 DynamoDBDeleteItemRequest oggetto 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 DynamoDBScanRequest per 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 DynamoDBSyncRequest oggetto 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 DynamoDBUpdateItemRequest oggetto 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 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 gli ID amici appena aggiunti (newFriendIds) 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 il contatore () di un amico di 10: 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 un amico () 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 gli ID amici appena aggiunti () a una lista di amici esistente (newFriendIds) 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. 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: 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 (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_pk record ds_sk e 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 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 acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne e. gsi_ds_pk gsi_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 si tratta di una stringa). Per le chiavi di partizione e ordinamento sono supportati solo i tipi di numeri e stringhe.

    Esempio

    Prendi il User tipo 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 customPartitionKey valore modifica il formato dei ds_pk record ds_sk e 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 User solo 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 acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle gsi_ds_pk colonne 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_ATTRIBUTES

      Restituisce 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_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 (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_pk egsi_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 100 elementi. Il valore massimo per questo campo è 1000 articoli.

  • 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 customPartitionKey valore modifica il formato ds_sk e i ds_pk record 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 (facoltativo)

    Un valore booleano che, se abilitato insieme acustomPartitionKey, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne e. gsi_ds_pk gsi_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 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 per ottenere dati dalla riga che hai inserito. Accetta * 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 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.