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à. # AWS AppSync JavaScript funzionalità di runtime per resolver e funzioni L'ambiente `APPSYNC_JS` di runtime offre funzionalità simili alla versione 6.0 [ECMAScript (ES).](https://262.ecma-international.org/6.0/) Supporta un sottoinsieme delle sue funzionalità e fornisce alcuni metodi aggiuntivi (utilità) che non fanno parte delle specifiche ES. Negli argomenti seguenti sono elencate tutte le funzionalità linguistiche supportate: + [Funzionalità di runtime supportate](https://docs.aws.amazon.com/appsync/latest/devguide/supported-features.html): scopri di più sulle funzionalità di base supportate, sugli oggetti primitivi, sugli oggetti e sulle funzioni incorporati, ecc. + [Utilità integrate](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html): la variabile util contiene metodi di utilità generali per aiutarti a lavorare con i dati. Se non diversamente specificato, tutte le utilità usano il set di caratteri UTF-8. + [Moduli integrati](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html): scopri di più su come i moduli integrati possono aiutare a scrivere JavaScript resolver e funzioni. + [Utilità di runtime](https://docs.aws.amazon.com/appsync/latest/devguide/runtime-utils-js.html): la libreria di runtime fornisce utilità per controllare o modificare le proprietà di runtime dei resolver e delle funzioni. + [Time helpers in util.time - La variabile util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time-js.html) contiene metodi datetime per aiutare a generare timestamp, convertire tra formati datetime e analizzare stringhe datetime. Si basa sulla sintassi per i formati datetime, a cui è possibile fare riferimento per ulteriore documentazione. [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) + [Helper DynamoDB in util.dynamodb - util.dynamodb contiene metodi di supporto che semplificano la scrittura e la lettura dei dati su Amazon DynamoDB, come la mappatura](https://docs.aws.amazon.com/appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html) e la formattazione automatiche dei tipi. + [Helper HTTP in util.http - L'utilità util.http fornisce metodi di supporto che è possibile utilizzare per gestire i parametri di richiesta HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http-js.html) e aggiungere intestazioni di risposta. + [Aiutanti di trasformazione in util.transform - util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform-js.html) contiene metodi di supporto che semplificano l'esecuzione di operazioni complesse sulle fonti di dati. + [String helpers in util.str - util.str](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str-js.html) contiene metodi per facilitare le operazioni più comuni sulle stringhe. + [Estensioni](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html): le estensioni contengono una serie di metodi per eseguire azioni aggiuntive all'interno dei resolver. + [Gli helper XML in util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-util-xml-js.html) - util.xml contengono metodi per facilitare la conversione di stringhe XML. **Nota** Attualmente, questo riferimento si applica solo alla versione di runtime **1.0.0**. # Funzionalità di runtime supportate Le sezioni seguenti descrivono il set di funzionalità supportate del runtime APPSYNC\$1JS. ## Caratteristiche principali Sono supportate le seguenti funzionalità principali. ------ #### [ Types ] Sono supportati i seguenti tipi: + numeri + stringhe + booleani + objects + matrici + funzioni ------ #### [ Operators ] Gli operatori sono supportati, tra cui: + operatori matematici standard (`+``-`,`/`,`%`,`*`, ecc.) + operatore di coalescenza nullo () `??` + Concatenamento opzionale () `?.` + operatori bit per bit + `void`e operatori `typeof` + operatori di diffusione (`...`) I seguenti operatori non sono supportati: + operatori unari (`++`,`--`, e`~`) + Operatore `in` **Nota** Utilizzate l'`Object.hasOwn`operatore per verificare se la proprietà specificata si trova nell'oggetto specificato. ------ #### [ Statements ] Sono supportate le seguenti istruzioni: + `const` + `let` + `var` + `break` + `else` + `for-in` + `for-of` + `if` + `return` + `switch` + sintassi diffusa Le seguenti non sono supportate: + `catch` + `continue` + `do-while` + `finally` + `for(initialization; condition; afterthought)` **Nota** Le eccezioni sono `for-in` e `for-of` le espressioni, che sono supportate. + `throw` + `try` + `while` + dichiarazioni etichettate ------ #### [ Literals ] Sono supportati i seguenti [valori letterali del modello](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) ES 6: + Stringhe multilinea + Interpolazione delle espressioni + Modelli di nidificazione ------ #### [ Functions ] È supportata la seguente sintassi della funzione: + Le dichiarazioni di funzione sono supportate. + Le funzioni a freccia ES 6 sono supportate. + È supportata la sintassi dei parametri rest di ES 6. ------ #### [ Strict mode ] Le funzioni funzionano in modalità rigorosa per impostazione predefinita, quindi non è necessario aggiungere una istruzione `use_strict` nel codice funzione. Non possono essere modificate. ------ ## Oggetti primitivi Sono supportati i seguenti oggetti primitivi di ES e le relative funzioni. ------ #### [ Object ] Sono supportati i seguenti oggetti: + `Object.assign()` + `Object.entries()` + `Object.hasOwn()` + `Object.keys()` + `Object.values()` + `delete` ------ #### [ String ] Sono supportate le seguenti stringhe: + `String.prototype.length()` + `String.prototype.charAt()` + `String.prototype.concat()` + `String.prototype.endsWith()` + `String.prototype.indexOf()` + `String.prototype.lastIndexOf()` + `String.raw()` + `String.prototype.replace()` **Nota** Le espressioni regolari non sono supportate. Tuttavia, i costrutti di espressioni regolari in stile Java sono supportati nel parametro fornito. [Per ulteriori informazioni, vedete Pattern.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) + `String.prototype.replaceAll()` **Nota** Le espressioni regolari non sono supportate. Tuttavia, i costrutti di espressioni regolari in stile Java sono supportati nel parametro fornito. [Per ulteriori informazioni, vedete Pattern.](https://docs.oracle.com/javase/8/docs/api/java/util/regex/Pattern.html) + `String.prototype.slice()` + `String.prototype.split()` + `String.prototype.startsWith()` + `String.prototype.toLowerCase()` + `String.prototype.toUpperCase()` + `String.prototype.trim()` + `String.prototype.trimEnd()` + `String.prototype.trimStart()` ------ #### [ Number ] Sono supportati i seguenti numeri: + `Number.isFinite` + `Number.isNaN` ------ ## Oggetti e funzioni incorporati Sono supportate le funzioni e gli oggetti seguenti. ------ #### [ Math ] Sono supportate le seguenti funzioni matematiche: + `Math.random()` + `Math.min()` + `Math.max()` + `Math.round()` + `Math.floor()` + `Math.ceil()` ------ #### [ Array ] Sono supportati i seguenti metodi di matrice: + `Array.prototype.length` + `Array.prototype.concat()` + `Array.prototype.fill()` + `Array.prototype.flat()` + `Array.prototype.indexOf()` + `Array.prototype.join()` + `Array.prototype.lastIndexOf()` + `Array.prototype.pop()` + `Array.prototype.push()` + `Array.prototype.reverse()` + `Array.prototype.shift()` + `Array.prototype.slice()` + `Array.prototype.sort()` **Nota** `Array.prototype.sort()`non supporta argomenti. + `Array.prototype.splice()` + `Array.prototype.unshift()` + `Array.prototype.forEach()` + `Array.prototype.map()` + `Array.prototype.flatMap()` + `Array.prototype.filter()` + `Array.prototype.reduce()` + `Array.prototype.reduceRight()` + `Array.prototype.find()` + `Array.prototype.some()` + `Array.prototype.every()` + `Array.prototype.findIndex()` + `Array.prototype.findLast()` + `Array.prototype.findLastIndex()` + `delete` ------ #### [ Console ] L'oggetto console è disponibile per il debug. Durante l'esecuzione delle query in tempo reale, log/error le istruzioni della console vengono inviate ad Amazon CloudWatch Logs (se la registrazione è abilitata). Durante la valutazione del codice con`evaluateCode`, le istruzioni di log vengono restituite nella risposta al comando. + `console.error()` + `console.log()` ------ #### [ Function ] + I `call` metodi `apply``bind`, e non sono supportati. + I costruttori di funzioni non sono supportati. + Il passaggio di una funzione come argomento non è supportato. + Le chiamate di funzioni ricorsive non sono supportate. ------ #### [ JSON ] Sono supportati i seguenti metodi JSON: + `JSON.parse()` **Nota** Restituisce una stringa vuota se la stringa analizzata non è un formato JSON valido. + `JSON.stringify()` ------ #### [ Promises ] I processi asincroni non sono supportati e le promesse non sono supportate. **Nota** L'accesso alla rete e al file system non è supportato nel `APPSYNC_JS` runtime di. AWS AppSync AWS AppSync gestisce tutte le operazioni di I/O in base alle richieste effettuate dal AWS AppSync resolver o dalla funzione. AWS AppSync ------ ## Elementi globali Sono supportate le seguenti costanti globali: + `NaN` + `Infinity` + `undefined` + [https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html) + [https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html) + `runtime` ## Tipi di errore Il lancio di errori con non `throw` è supportato. È possibile restituire un errore utilizzando `util.error()` la funzione. È possibile includere un errore nella risposta GraphQL utilizzando la `util.appendError` funzione. Per ulteriori informazioni, consulta [Error utils](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-util-js.html#utility-helpers-in-error-js). # Utilità integrate La `util` variabile contiene metodi di utilità generali per aiutarvi a lavorare con i dati. Se non diversamente specificato, tutte le utilità usano il set di caratteri UTF-8. ## Utilità di codifica ### Elenco degli strumenti di codifica **`util.urlEncode(String)`** Restituisce la stringa di input come stringa codificata `application/x-www-form-urlencoded`. **`util.urlDecode(String)`** Decodifica una stringa codificata `application/x-www-form-urlencoded` nella relativa forma non codificata. **`util.base64Encode(string) : string`** Codifica l'input in una stringa con codifica base64. **`util.base64Decode(string) : string`** Decodifica i dati da una stringa con codifica base64. ## Utilità per la generazione di ID ### Elenco di utilità per la generazione di ID **`util.autoId()`** Restituisce un valore UUID generato casualmente a 128 bit. **`util.autoUlid()`** Restituisce un ULID (Universally Unique Lexicographically Sortable Identifier) generato casualmente a 128 bit. **`util.autoKsuid()`** Restituisce un KSUID (K-Sortable Unique Identifier) base62 generato casualmente a 128 bit codificato come String con una lunghezza di 27. ## Utili di errore ### Elenco delle utilità di errore **`util.error(String, String?, Object?, Object?)`** Genera un errore personalizzato. Può essere usato nei modelli di mappatura di richieste o risposte se il modello rileva un errore nella richiesta o nel risultato della chiamata. Inoltre, è `errorType` possibile specificare un `data` campo, un `errorInfo` campo e un campo. Il valore di `data` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. `data`verrà filtrato in base al set di selezione dell'interrogazione. Il valore di `errorInfo` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. `errorInfo`**non** verrà filtrato in base al set di selezione delle interrogazioni. **`util.appendError(String, String?, Object?, Object?)`** Aggiunge un errore personalizzato. Può essere usato nei modelli di mappatura di richieste o risposte se il modello rileva un errore nella richiesta o nel risultato della chiamata. Inoltre, è `errorType` possibile specificare un `data` campo, un `errorInfo` campo e un campo. A differenza di `util.error(String, String?, Object?, Object?)`, la valutazione del modello non viene interrotta, in modo che i dati possano essere restituiti al chiamante. Il valore di `data` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. `data`verrà filtrato in base al set di selezione dell'interrogazione. Il valore di `errorInfo` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. `errorInfo`**non** verrà filtrato in base al set di selezione delle interrogazioni. ## Utilità per la corrispondenza di tipi e modelli ### Elenco degli strumenti per la corrispondenza di tipi e modelli **`util.matches(String, String) : Boolean`** Restituisce true se il modello specificato nel primo argomento corrisponde ai dati forniti nel secondo argomento. Il modello deve essere un'espressione regolare, ad esempio `util.matches("a*b", "aaaaab")`. La funzionalità si basa sulla classe [Pattern](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html) che puoi consultare per ottenere altre informazioni. **`util.authType()`** Restituisce una stringa che descrive il tipo di autenticazione multipla utilizzato da una richiesta, restituendo «IAM Authorization», «User Pool Authorization», «Open ID Connect Authorization» o «API Key Authorization». ## Restituisce il valore di comportamento (utils) ### Elenco delle utilità di comportamento del valore restituito **`util.escapeJavaScript(String)`** Restituisce la stringa di input come stringa di JavaScript escape. ## Utilità di autorizzazione Resolver ### Elenco degli strumenti di autorizzazione del resolver **`util.unauthorized()`** Genera `Unauthorized` per il campo in fase di risoluzione. Utilizzalo nei modelli di mappatura delle richieste o delle risposte per determinare se consentire al chiamante di risolvere il campo. # Moduli incorporati I moduli fanno parte del `APPSYNC_JS` runtime e forniscono utilità per aiutare a scrivere JavaScript resolver e funzioni. Per esempi ed esempi, consultate 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 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 #### Elenco delle funzioni **` get(payload: GetInput): DynamoDBGetItemRequest`** [Input](#built-in-ddb-modules-inputs)Per informazioni su, vedere GetInput. Genera un `DynamoDBGetItemRequest` oggetto per effettuare una [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-getitem)richiesta a DynamoDB. ``` import { get } from '@aws-appsync/utils/dynamodb'; export function request(ctx) { return get({ key: { id: ctx.args.id } }); } ``` **`put(payload): DynamoDBPutItemRequest`** Genera un `DynamoDBPutItemRequest` oggetto per effettuare una [PutItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-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(payload): DynamoDBDeleteItemRequest`** Genera un `DynamoDBDeleteItemRequest` oggetto per effettuare una [DeleteItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-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(payload): DynamoDBScanRequest`** Genera una richiesta `DynamoDBScanRequest` di [scansione](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan) 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(payload): DynamoDBSyncRequest`** Genera un `DynamoDBSyncRequest` oggetto per effettuare una richiesta di [sincronizzazione](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-sync). 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(payload): DynamoDBUpdateItemRequest`** Genera un `DynamoDBUpdateItemRequest` oggetto per effettuare una [UpdateItem](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-updateitem)richiesta 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'; ``` #### Elenco delle operazioni **`add(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 (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 (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 (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 (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 #### Elenco degli input **`Type GetInput`** ``` GetInput: { consistentRead?: boolean; key: DynamoDBKey; } ``` **Dichiarazione del tipo** + `consistentRead?: boolean` (facoltativo) Un booleano opzionale per specificare se si desidera eseguire una lettura fortemente coerente con DynamoDB. + `key: DynamoDBKey`(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`** ``` PutInput: { _version?: number; condition?: DynamoDBFilterObject | null; customPartitionKey?: string; item: Partial; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Dichiarazione del tipo** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject | null` (facoltativo) 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` (facoltativo) 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`(richiesto) Il resto degli attributi dell'elemento da inserire in DynamoDB. + `key: DynamoDBKey`(richiesto) 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` (facoltativo) Un valore booleano che, se abilitato insieme a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne and. `gsi_ds_pk` `gsi_ds_sk` Per ulteriori informazioni, consulta [Rilevamento e sincronizzazione dei conflitti](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella Guida per gli *AWS AppSync sviluppatori*. **`Type QueryInput`** ``` QueryInput: ScanInput & { query: DynamoDBKeyCondition>; } ``` **Dichiarazione del tipo** + `query: DynamoDBKeyCondition>`(richiesto) 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: `id``name`, e`age`: ``` const query: QueryInput = { name: { eq: 'John' }, age: { gt: 20 }, } ``` **`Type RemoveInput`** ``` RemoveInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; } ``` **Dichiarazione di tipo** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject` (facoltativo) 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'`DeleteItem`espressione 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 = { owner: { eq: 'XXXXXXXXXXXXXXXX' }, } remove({ key: { id: 'XXXXXXXXXXXXXXXX', }, condition, }); ``` + `customPartitionKey?: string` (facoltativo) 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`(richiesto) 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 utente`id`, la chiave sarebbe simile a questa: ``` type User = { id: number name: string age: number isVerified: boolean } const key: DynamoDBKey = { 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 = { 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 nelle `gsi_ds_pk` colonne and. `gsi_ds_sk` **`Type ScanInput`** ``` ScanInput: { consistentRead?: boolean | null; filter?: DynamoDBFilterObject | 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` (facoltativo) Un booleano opzionale per indicare letture coerenti quando si esegue una query su DynamoDB. Il valore predefinito è `false`. + `filter?: DynamoDBFilterObject | 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 booleano opzionale per indicare se la query 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 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 in`ProjectionExpression`. Questo valore restituito equivale a specificare `ProjectionExpression` senza specificare alcun valore per. `AttributesToGet` + `totalSegments?: number` (facoltativo) **`Type DynamoDBSyncInput`** ``` DynamoDBSyncInput: { basePartitionKey?: string; deltaIndexName?: string; filter?: DynamoDBFilterObject | null; lastSync?: number; limit?: number | null; nextToken?: string | null; } ``` **Dichiarazione del tipo** + `basePartitionKey?: string` (facoltativo) 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` (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` and`gsi_ds_sk`). + `filter?: DynamoDBFilterObject | null` (facoltativo) Un filtro opzionale da applicare ai risultati dopo averlo recuperato dalla tabella. + `lastSync?: number` (facoltativo) 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` (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`** ``` DynamoDBUpdateInput: { _version?: number; condition?: DynamoDBFilterObject; customPartitionKey?: string; key: DynamoDBKey; populateIndexFields?: boolean; update: DynamoDBUpdateObject; } ``` **Tipo di dichiarazione** + `_version?: number` (facoltativo) + `condition?: DynamoDBFilterObject` (facoltativo) 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` (facoltativo) 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`(richiesto) 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 and. `gsi_ds_pk` `gsi_ds_sk` + `update: DynamoDBUpdateObject` 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`, `append``prepend`,`updateListItem`. ## Funzioni del modulo Amazon RDS Le funzioni del modulo Amazon RDS offrono 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 utilizza`sql`: ``` import { sql } from '@aws-appsync/utils/rds'; ``` ### Funzioni È possibile utilizzare gli assistenti di utilità del modulo AWS AppSync RDS per interagire con il database. #### Select L'`select`utilità crea un'`SELECT`istruzione 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 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 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** È possibile 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 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 } } ]} })); } ``` È 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 | Piace | stringa | | Non contiene | Non come | 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 | #### Insert L'`insert`utilità 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) } ``` **Caso d'uso MySQL** Puoi combinare un `insert` seguito da a per `select` 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 [https://www.postgresql.org/docs/current/dml-returning.html](https://www.postgresql.org/docs/current/dml-returning.html)per 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) } ``` #### Aggiorna L'`update`utilità 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 di`3`, ma solo se li conosciamo (`known_since`) dall'anno`2000`: ``` 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 segno di spunta alla nostra condizione per assicurarci che venga aggiornata solo la riga con la chiave primaria `id` uguale a`3`. Allo stesso modo, per Postgres`inserts`, è possibile utilizzare `returning` per restituire i dati modificati. #### Rimuovi L'`remove`utilità 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. `remove`dovrebbe 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 lo [stesso tipo di suggerimenti](https://docs.aws.amazon.com//rdsdataservice/latest/APIReference/API_SqlParameter.html#rdsdtataservice-Type-SqlParameter-typeHint) della Data 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 oggetto JSON. Utilizziamo 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` e`TIME`: `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 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. # - Utilità di runtime La `runtime` libreria fornisce utilità per controllare o modificare le proprietà di runtime dei resolver e delle funzioni. ## Elenco delle utilità di runtime **`runtime.earlyReturn(obj?: unknown, returnOptions?: {skipTo: 'END' | 'NEXT'}): never`** L'invocazione di questa funzione interromperà l'esecuzione del gestore, della AWS AppSync funzione o del resolver corrente (Unit o Pipeline Resolver) a seconda del contesto corrente. L'oggetto specificato viene restituito come risultato. + Quando viene chiamato in un gestore di richieste di AWS AppSync funzioni, l'origine dati e il gestore di risposta vengono ignorati e viene chiamato il gestore della richiesta di funzione successivo (o il gestore di risposte del resolver della pipeline se questa era l'ultima funzione). AWS AppSync + Quando viene chiamato in un gestore di richieste del resolver AWS AppSync della pipeline, l'esecuzione della pipeline viene saltata e il gestore di risposte del resolver della pipeline viene chiamato immediatamente. + Quando `returnOptions` viene fornito con `skipTo` impostato su «END», l'esecuzione della pipeline viene saltata e il gestore di risposta del resolver della pipeline viene chiamato immediatamente. + Quando `returnOptions` viene fornito con `skipTo` impostato su «NEXT», l'esecuzione della funzione viene saltata e viene chiamato il successivo gestore di pipeline. **Esempio** ``` import { runtime } from '@aws-appsync/utils' export function request(ctx) { runtime.earlyReturn({ hello: 'world' }) // code below is not executed return ctx.args } // never called because request returned early export function response(ctx) { return ctx.result } ``` # Aiutanti temporali in util.time La variabile `util.time` contiene metodi datetime che consentono di generare timestamp, convertire i diversi formati datetime e analizzare le stringhe datetime. La sintassi per i formati datetime si basa sulla [DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)quale è possibile fare riferimento per ulteriore documentazione. ## Elenco delle utilità temporali **`util.time.nowISO8601()`** [Restituisce una rappresentazione String di UTC in ISO8601 formato.](https://en.wikipedia.org/wiki/ISO_8601) **`util.time.nowEpochSeconds()`** Restituisce il numero di secondi dall'epoca (Unix epoch) 1970-01-01T00:00:00Z a ora. **`util.time.nowEpochMilliSeconds()`** Restituisce il numero di millisecondi dall'epoca (Unix epoch) 1970-01-01T00:00:00Z a ora. **`util.time.nowFormatted(String)`** Restituisce una stringa del timestamp corrente in UTC utilizzando il formato specificato da un tipo di input stringa. **`util.time.nowFormatted(String, String)`** Restituisce una stringa del timestamp corrente per un fuso orario utilizzando il formato e il fuso orario specificati da tipi di input stringa. **`util.time.parseFormattedToEpochMilliSeconds(String, String)`** Analizza un timestamp passato come String insieme a un formato contenente un fuso orario, quindi restituisce il timestamp in millisecondi dall'epoca. **`util.time.parseFormattedToEpochMilliSeconds(String, String, String)`** Analizza un timestamp passato come String insieme a un formato e a un fuso orario, quindi restituisce il timestamp in millisecondi dall'epoca. **`util.time.parseISO8601ToEpochMilliSeconds(String)`** Analizza un ISO8601 timestamp passato come String, quindi restituisce il timestamp in millisecondi trascorsi da epoch. **`util.time.epochMilliSecondsToSeconds(long)`** Converte un timestamp in formato epoca (Unix epoch) espresso in millisecondi in un timestamp in formato epoca (Unix epoch) espresso in secondi. **`util.time.epochMilliSecondsToISO8601(long)`** Converte il timestamp di un'epoca in millisecondi in un timestamp. ISO8601 **`util.time.epochMilliSecondsToFormatted(long, String)`** Converte il timestamp di un'epoca in millisecondi, passato così a lungo, in un timestamp formattato secondo il formato fornito in UTC. **`util.time.epochMilliSecondsToFormatted(long, String, String)`** Converte il timestamp di un'epoca in millisecondi, passato come long, in un timestamp formattato secondo il formato fornito nel fuso orario fornito. # Aiutanti DynamoDB in util.dynamodb `util.dynamodb`contiene metodi di supporto che semplificano la scrittura e la lettura dei dati su Amazon DynamoDB, come la mappatura e la formattazione automatiche dei tipi. ## A DynamoDB ### Elenco di utilità ToDynamoDB **`util.dynamodb.toDynamoDB(Object)`** Strumento generale di conversione degli oggetti per DynamoDB che converte gli oggetti di input nella rappresentazione DynamoDB appropriata. Rappresenta alcuni tipi in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. **Esempio di stringa** ``` Input: util.dynamodb.toDynamoDB("foo") Output: { "S" : "foo" } ``` **Esempio di numero** ``` Input: util.dynamodb.toDynamoDB(12345) Output: { "N" : 12345 } ``` **Esempio booleano** ``` Input: util.dynamodb.toDynamoDB(true) Output: { "BOOL" : true } ``` **Esempio di elenco** ``` Input: util.dynamodb.toDynamoDB([ "foo", 123, { "bar" : "baz" } ]) Output: { "L" : [ { "S" : "foo" }, { "N" : 123 }, { "M" : { "bar" : { "S" : "baz" } } } ] } ``` **Esempio di mappa** ``` Input: util.dynamodb.toDynamoDB({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "M" : { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } } ``` ## Utilità ToString ### Elenco di utilità ToString **`util.dynamodb.toString(String)`** Converte una stringa di input nel formato stringa DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toString("foo") Output: { "S" : "foo" } ``` **`util.dynamodb.toStringSet(List)`** Converte un elenco con stringhe nel formato del set di stringhe DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toStringSet([ "foo", "bar", "baz" ]) Output: { "SS" : [ "foo", "bar", "baz" ] } ``` ## ToNumber utils ### Elenco di utilità ToNumber **`util.dynamodb.toNumber(Number)`** Converte un numero nel formato numerico DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toNumber(12345) Output: { "N" : 12345 } ``` **`util.dynamodb.toNumberSet(List)`** Converte un elenco di numeri nel formato del set di numeri DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toNumberSet([ 1, 23, 4.56 ]) Output: { "NS" : [ 1, 23, 4.56 ] } ``` ## ToBinary utils ### Elenco di utilità ToBinary **`util.dynamodb.toBinary(String)`** Converte i dati binari codificati come stringa base64 in formato binario DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toBinary("foo") Output: { "B" : "foo" } ``` **`util.dynamodb.toBinarySet(List)`** Converte un elenco di dati binari codificati come stringhe base64 in formato set binario DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toBinarySet([ "foo", "bar", "baz" ]) Output: { "BS" : [ "foo", "bar", "baz" ] } ``` ## ToBoolean utils ### Elenco degli strumenti ToBoolean **`util.dynamodb.toBoolean(Boolean)`** Converte un booleano nel formato booleano DynamoDB appropriato. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toBoolean(true) Output: { "BOOL" : true } ``` ## ToNull utils ### Elenco di utilità ToNull **`util.dynamodb.toNull()`** Restituisce un valore null nel formato null di DynamoDB. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toNull() Output: { "NULL" : null } ``` ## Utilità ToList ### Elenco di utilità ToList **`util.dynamodb.toList(List)`** Converte un elenco di oggetti nel formato elenco DynamoDB. Ogni elemento dell'elenco viene inoltre convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toList([ "foo", 123, { "bar" : "baz" } ]) Output: { "L" : [ { "S" : "foo" }, { "N" : 123 }, { "M" : { "bar" : { "S" : "baz" } } } ] } ``` ## Utilità ToMap ### Elenco di utilità ToMap **`util.dynamodb.toMap(Map)`** Converte una mappa nel formato di mappa DynamoDB. Ogni valore nella mappa viene inoltre convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toMap({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "M" : { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } } ``` **`util.dynamodb.toMapValues(Map)`** Crea una copia della mappa in cui ogni valore è stato convertito nel formato DynamoDB appropriato. Rappresenta alcuni oggetti nidificati in un determinato modo. Ad esempio, usa elenchi ("L") invece di set ("SS", "NS", "BS"). ``` Input: util.dynamodb.toMapValues({ "foo": "bar", "baz" : 1234, "beep": [ "boop"] }) Output: { "foo" : { "S" : "bar" }, "baz" : { "N" : 1234 }, "beep" : { "L" : [ { "S" : "boop" } ] } } ``` Questo è leggermente diverso dal fatto che restituisce solo il contenuto del valore dell'attributo DynamoDB, ma non l'intero valore dell'attributo `util.dynamodb.toMap(Map)` stesso. Ad esempio, le istruzioni seguenti sono identiche: ``` util.dynamodb.toMapValues() util.dynamodb.toMap()("M") ``` ## Utilità S3Object ### Elenco delle utilità di S3Object **`util.dynamodb.toS3Object(String key, String bucket, String region)`** Converte la chiave, il bucket e la regione nella rappresentazione dell'oggetto DynamoDB S3. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", region = "baz") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo", \"bucket\" : \"bar", \"region\" : \"baz" } }" } ``` **`util.dynamodb.toS3Object(String key, String bucket, String region, String version)`** Converte la chiave, il bucket, la regione e la versione opzionale nella rappresentazione dell'oggetto DynamoDB S3. Questo restituisce un oggetto che descrive il valore dell'attributo DynamoDB. ``` Input: util.dynamodb.toS3Object("foo", "bar", "baz", "beep") Output: { "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" } ``` **`util.dynamodb.fromS3ObjectJson(String)`** Accetta il valore stringa di un oggetto DynamoDB S3 e restituisce una mappa che contiene la chiave, il bucket, la regione e la versione opzionale. ``` Input: util.dynamodb.fromS3ObjectJson({ "S" : "{ \"s3\" : { \"key\" : \"foo\", \"bucket\" : \"bar\", \"region\" : \"baz\", \"version\" = \"beep\" } }" }) Output: { "key" : "foo", "bucket" : "bar", "region" : "baz", "version" : "beep" } ``` # Helper HTTP in util.http L'`util.http`utilità fornisce metodi di supporto che è possibile utilizzare per gestire i parametri di richiesta HTTP e aggiungere intestazioni di risposta. ## elenco di utilità util.http **`util.http.copyHeaders(headers)`** Copia le intestazioni dalla mappa, escluse le seguenti intestazioni HTTP con restrizioni: + transfer-encoding + connection + host + expect + keep-alive + upgrade + proxy-authenticate + proxy-authorization + te + content-length **`util.http.addResponseHeader(String, Object)`** Aggiunge una singola intestazione personalizzata con il nome (`String`) e il valore (`Object`) della risposta. Si applicano le limitazioni seguenti: + Oltre all'elenco delle intestazioni con restrizioni per`copyHeaders(headers)`, i nomi delle intestazioni non possono corrispondere a nessuno dei seguenti: + Access-Control-Allow-Credentials + Access-Control-Allow-Origin + Access-Control-Expose-Headers + Access-Control-Max-Age + Access-Control-Allow-Methods + Access-Control-Allow-Headers + Vary + Content-Type + I nomi delle intestazioni non possono iniziare con i prefissi limitati o. `x-amzn-` `x-amz-` + La dimensione delle intestazioni di risposta personalizzate non può superare i 4 KB. Sono inclusi i nomi e i valori delle intestazioni. + È necessario definire ogni intestazione di risposta una volta per operazione GraphQL. Tuttavia, se definisci più volte un'intestazione personalizzata con lo stesso nome, nella risposta viene visualizzata la definizione più recente. Tutte le intestazioni vengono conteggiate ai fini del limite di dimensione dell'intestazione indipendentemente dalla denominazione. + Le intestazioni con un nome vuoto o limitato `(String)` o un valore nullo verranno ignorate e `(Object)` genereranno un `ResponseHeaderError` errore che viene aggiunto all'output dell'operazione. `errors` ``` export function request(ctx) { util.http.addResponseHeader('itemsCount', 7) util.http.addResponseHeader('render', ctx.args.render) return {} } ``` **`util.http.addResponseHeaders(Map)`** Aggiunge più intestazioni di risposta alla risposta dalla mappa di nomi e valori specificata. `(String)` `(Object)` Le stesse limitazioni elencate per il `addResponseHeader(String, Object)` metodo si applicano anche a questo metodo. ``` export function request(ctx) { const headers = { headerInt: 12, headerString: 'stringValue', headerObject: { field1: 7, field2: 'string' } } util.http.addResponseHeaders(headers) return {} } ``` # Aiutanti di trasformazione in util.transform `util.transform`contiene metodi di supporto che semplificano l'esecuzione di operazioni complesse su fonti di dati. ## Elenco di utilità degli aiutanti di trasformazione **`util.transform.toDynamoDBFilterExpression(filterObject: DynamoDBFilterObject) : string`** Converte una stringa di input in un'espressione di filtro da utilizzare con DynamoDB. Si consiglia l'utilizzo `toDynamoDBFilterExpression` con le [funzioni integrate](https://docs.aws.amazon.com/appsync/latest/devguide/built-in-modules-js.html) del modulo. **`util.transform.toElasticsearchQueryDSL(object: OpenSearchQueryObject) : string`** Converte l'input dato nella sua espressione OpenSearch Query DSL equivalente, restituendola come stringa JSON. **Esempio di input:** ``` util.transform.toElasticsearchQueryDSL({ "upvotes":{ "ne":15, "range":[ 10, 20 ] }, "title":{ "eq":"hihihi", "wildcard":"h*i" } }) ``` **Output di esempio:** ``` { "bool":{ "must":[ { "bool":{ "must":[ { "bool":{ "must_not":{ "term":{ "upvotes":15 } } } }, { "range":{ "upvotes":{ "gte":10, "lte":20 } } } ] } }, { "bool":{ "must":[ { "term":{ "title":"hihihi" } }, { "wildcard":{ "title":"h*i" } } ] } } ] } } ``` Si presume che l'operatore predefinito sia AND. **`util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter`** Converte un oggetto `Map` di input in un oggetto `SubscriptionFilter` espressione. Il `util.transform.toSubscriptionFilter` metodo viene utilizzato come input per l'`extensions.setSubscriptionFilter()`estensione. Per ulteriori informazioni, consulta [Estensioni](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). I parametri e l'istruzione return sono elencati di seguito: *Parametri* + `objFilter`: `SubscriptionFilterObject` Un oggetto `Map` di input che viene convertito nell'oggetto `SubscriptionFilter` espressione. + `ignoredFields`: `SubscriptionFilterExcludeKeysType` (opzionale) Uno `List` dei nomi di campo nel primo oggetto che verrà ignorato. + `rules`: `SubscriptionFilterRuleObject` (opzionale) Un oggetto `Map` di input con regole rigorose che viene incluso durante la costruzione dell'oggetto `SubscriptionFilter` espressione. Queste regole rigorose verranno incluse nell'oggetto `SubscriptionFilter` espressione in modo che almeno una delle regole venga soddisfatta per passare il filtro di sottoscrizione. *Risposta* Restituisce una `[SubscriptionFilter](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html)`. **`util.transform.toSubscriptionFilter(Map, List)`** Converte un oggetto `Map` di input in un oggetto `SubscriptionFilter` espressione. Il `util.transform.toSubscriptionFilter` metodo viene utilizzato come input per l'`extensions.setSubscriptionFilter()`estensione. Per ulteriori informazioni, consulta [Estensioni](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). Il primo argomento è l'oggetto `Map` di input che viene convertito nell'oggetto `SubscriptionFilter` espressione. Il secondo argomento riguarda i nomi `List` di campo che vengono ignorati nel primo oggetto `Map` di input durante la costruzione dell'oggetto `SubscriptionFilter` espressione. **`util.transform.toSubscriptionFilter(Map, List, Map)`** Converte un oggetto `Map` di input in un `SubscriptionFilter` oggetto espressione. Il `util.transform.toSubscriptionFilter` metodo viene utilizzato come input per l'`extensions.setSubscriptionFilter()`estensione. Per ulteriori informazioni, consulta [Estensioni](https://docs.aws.amazon.com/appsync/latest/devguide/extensions-js.html). **`util.transform.toDynamoDBConditionExpression(conditionObject)`** Crea un'espressione di condizione DynamoDB. ## Argomenti del filtro di abbonamento La tabella seguente spiega come vengono definiti gli argomenti delle seguenti utilità: + `Util.transform.toSubscriptionFilter(objFilter, ignoredFields?, rules?): SubscriptionFilter` ------ #### [ Argument 1: Map ] L'argomento 1 è un `Map` oggetto con i seguenti valori chiave: + nomi di campo + «e» + «o» Per i nomi di campo come chiavi, le condizioni sulle voci di questi campi sono nel formato di. `"operator" : "value"` L'esempio seguente mostra come aggiungere voci a: `Map` ``` "field_name" : { "operator1" : value } ## We can have multiple conditions for the same field_name: "field_name" : { "operator1" : value "operator2" : value . . . } ``` Quando un campo contiene due o più condizioni, si considera che tutte queste condizioni utilizzino l'operazione OR. L'input `Map` può anche avere «e» e «or» come chiavi, il che implica che tutte le voci al suo interno devono essere unite utilizzando la logica AND o OR a seconda della chiave. I valori chiave «and» e «or» prevedono una serie di condizioni. ``` "and" : [ { "field_name1" : { "operator1" : value } }, { "field_name2" : { "operator1" : value } }, . . ]. ``` Nota che puoi annidare «and» e «or». Cioè, puoi aver annidato «e» /"or» all'interno di un altro blocco «e» /"or». Tuttavia, questo non funziona per campi semplici. ``` "and" : [ { "field_name1" : { "operator" : value } }, { "or" : [ { "field_name2" : { "operator" : value } }, { "field_name3" : { "operator" : value } } ]. ``` L'esempio seguente mostra un input dell'*argomento 1* utilizzando`util.transform.toSubscriptionFilter(Map) : Map`. **Ingresso/i** Argomento 1: Mappa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 2000 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` **Output** Il risultato è un `Map` oggetto: ``` { "filterGroup": [ { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "lte", "value": 50 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "author", "operator": "eq", "value": "Admin" } ] }, { "filters": [ { "fieldName": "percentageUp", "operator": "gte", "value": 20 }, { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 2000 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 2: List ] L'argomento 2 contiene una `List` serie di nomi di campo che non devono essere considerati nell'input `Map` (argomento 1) durante la costruzione dell'oggetto `SubscriptionFilter` espressione. `List`Possono anche essere vuoti. L'esempio seguente mostra gli input dell'argomento 1 e dell'argomento 2 utilizzando`util.transform.toSubscriptionFilter(Map, List) : Map`. **Ingresso/i** Argomento 1: Mappa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "gt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argomento 2: Elenco: ``` ["percentageUp", "author"] ``` **Output** Il risultato è un `Map` oggetto: ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false } ] } ] } ``` ------ #### [ Argument 3: Map ] L'argomento 3 è un `Map` oggetto che ha nomi di campo come valori chiave (non può avere «and» o «or»). Per i nomi di campo come chiavi, le condizioni in questi campi sono voci nel formato di`"operator" : "value"`. A differenza dell'argomento 1, l'argomento 3 non può avere più condizioni nella stessa chiave. Inoltre, l'argomento 3 non contiene una clausola «and» o «or», quindi non è prevista nemmeno la nidificazione. L'argomento 3 rappresenta un elenco di regole rigorose, che vengono aggiunte all'oggetto `SubscriptionFilter` espressione in modo che venga soddisfatta **almeno una** di queste condizioni per passare il filtro. ``` { "fieldname1": { "operator": value }, "fieldname2": { "operator": value } } . . . ``` L'esempio seguente mostra gli input dell'*argomento 1*, dell'*argomento 2* e dell'*argomento 3* utilizzando`util.transform.toSubscriptionFilter(Map, List, Map) : Map`. **Ingresso/i** Argomento 1: Mappa: ``` { "percentageUp": { "lte": 50, "gte": 20 }, "and": [ { "title": { "ne": "Book1" } }, { "downvotes": { "lt": 20 } } ], "or": [ { "author": { "eq": "Admin" } }, { "isPublished": { "eq": false } } ] } ``` Argomento 2: Elenco: ``` ["percentageUp", "author"] ``` Argomento 3: Mappa: ``` { "upvotes": { "gte": 250 }, "author": { "eq": "Person1" } } ``` **Output** Il risultato è un `Map` oggetto: ``` { "filterGroup": [ { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "upvotes", "operator": "gte", "value": 250 } ] }, { "filters": [ { "fieldName": "title", "operator": "ne", "value": "Book1" }, { "fieldName": "downvotes", "operator": "gt", "value": 20 }, { "fieldName": "isPublished", "operator": "eq", "value": false }, { "fieldName": "author", "operator": "eq", "value": "Person1" } ] } ] } ``` ------ # String helper in util.str `util.str`contiene metodi per facilitare le operazioni più comuni sulle stringhe. ## elenco di utilità util.str **`util.str.normalize(String, String)`** Normalizza una stringa utilizzando uno dei quattro moduli di normalizzazione Unicode: NFC, NFD, NFKC o NFKD. Il primo argomento è la stringa da normalizzare. Il secondo argomento è «nfc», «nfd», «nfkc» o «nfkd» e specifica il tipo di normalizzazione da utilizzare per il processo di normalizzazione. # Estensioni `extensions`contiene una serie di metodi per eseguire azioni aggiuntive all'interno dei resolver. ## Estensioni di memorizzazione nella cache **`extensions.evictFromApiCache(typeName: string, fieldName: string, keyValuePair: Record) : Object`** Rimuove un elemento dalla cache lato server. AWS AppSync Il primo argomento è il nome del tipo. Il secondo argomento è il nome del campo. Il terzo argomento è un oggetto contenente elementi della coppia chiave-valore che specificano il valore della chiave di memorizzazione nella cache. È necessario inserire gli elementi nell'oggetto nello stesso ordine delle chiavi di memorizzazione nella cache del resolver memorizzato nella cache. `cachingKey` [Per ulteriori informazioni sulla memorizzazione nella cache, vedete Comportamento della memorizzazione nella cache.](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html#caching-behavior) **Esempio 1:** Questo esempio rimuove gli elementi che sono stati memorizzati nella cache di un resolver chiamato `Query.allClasses` su cui è stata utilizzata una chiave di memorizzazione nella cache chiamata. `context.arguments.semester` Quando viene chiamata la mutazione e il resolver viene eseguito, se una voce viene cancellata con successo, la risposta contiene un `apiCacheEntriesDeleted` valore nell'oggetto extensions che mostra quante voci sono state eliminate. ``` import { util, extensions } from '@aws-appsync/utils'; export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.evictFromApiCache('Query', 'allClasses', { 'context.arguments.semester': ctx.args.semester, }); return null; } ``` Questa funzione funziona **solo** per le mutazioni, non per le interrogazioni. ## Estensioni di abbonamento **`extensions.setSubscriptionFilter(filterJsonObject)`** Definisce filtri di abbonamento avanzati. Ogni evento di notifica di sottoscrizione viene valutato sulla base dei filtri di sottoscrizione forniti e invia notifiche ai clienti se tutti i filtri lo confermano. `true` L'argomento è `filterJsonObject` (ulteriori informazioni su questo argomento sono disponibili di seguito nella filterJsonObject sezione *Argomento:*). Vedi [Filtraggio avanzato degli abbonamenti.](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html) È possibile utilizzare questa funzione di estensione solo nel gestore delle risposte di un resolver di sottoscrizioni. Inoltre, ti consigliamo di utilizzarla `util.transform.toSubscriptionFilter` per creare il tuo filtro. **`extensions.setSubscriptionInvalidationFilter(filterJsonObject)`** Definisce i filtri di invalidazione dell'abbonamento. I filtri di sottoscrizione vengono valutati in base al payload di invalidazione, quindi invalidano un determinato abbonamento se i filtri restituiscono lo stesso risultato. `true` *L'argomento è `filterJsonObject` (ulteriori informazioni su questo argomento sono disponibili più avanti nella sezione Argomento:). filterJsonObject* Vedi [Filtraggio avanzato degli abbonamenti.](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-enhanced-filtering.html) È possibile utilizzare questa funzione di estensione solo nel gestore delle risposte di un resolver di sottoscrizioni. Inoltre, ti consigliamo di utilizzarla `util.transform.toSubscriptionFilter` per creare il tuo filtro. **`extensions.invalidateSubscriptions(invalidationJsonObject)`** Utilizzato per avviare l'invalidazione dell'abbonamento a seguito di una mutazione. L'argomento è `invalidationJsonObject` (ulteriori informazioni su questo argomento sono disponibili di seguito nella sezione *Argomento: invalidationJsonObject*). Questa estensione può essere utilizzata solo nei modelli di mappatura delle risposte dei risolutori di mutazioni. È possibile utilizzare al massimo cinque chiamate di `extensions.invalidateSubscriptions()` metodo uniche in ogni singola richiesta. Se superi questo limite, riceverai un errore GraphQL. ## Argomento: filterJsonObject L'oggetto JSON definisce i filtri di sottoscrizione o di invalidazione. È una serie di filtri in un. `filterGroup` Ogni filtro è una raccolta di filtri individuali. ``` { "filterGroup": [ { "filters" : [ { "fieldName" : "userId", "operator" : "eq", "value" : 1 } ] }, { "filters" : [ { "fieldName" : "group", "operator" : "in", "value" : ["Admin", "Developer"] } ] } ] } ``` Ogni filtro ha tre attributi: + `fieldName`— Il campo dello schema GraphQL. + `operator`— Il tipo di operatore. + `value`— I valori da confrontare con il `fieldName` valore di notifica dell'abbonamento. Di seguito è riportato un esempio di assegnazione di questi attributi: ``` { "fieldName" : "severity", "operator" : "le", "value" : context.result.severity } ``` ## Argomento: invalidationJsonObject `invalidationJsonObject`Definisce quanto segue: + `subscriptionField`— L'abbonamento allo schema GraphQL da invalidare. Un singolo abbonamento, definito come una stringa in`subscriptionField`, viene considerato invalidato. + `payload`— Un elenco di coppie chiave-valore che viene utilizzato come input per invalidare le sottoscrizioni se il filtro di invalidazione valuta in base ai relativi valori. `true` L'esempio seguente invalida i client sottoscritti e connessi che utilizzano l'abbonamento quando il filtro di invalidazione definito nel resolver di `onUserDelete` sottoscrizione restituisce un risultato conforme al valore. `true` `payload` ``` export const request = (ctx) => ({ payload: null }); export function response(ctx) { extensions.invalidateSubscriptions({ subscriptionField: 'onUserDelete', payload: { group: 'Developer', type: 'Full-Time' }, }); return ctx.result; } ``` # Helper XML in util.xml `util.xml`contiene metodi per facilitare la conversione di stringhe XML. ## elenco di utilità di util.xml **`util.xml.toMap(String) : Object`** Converte una stringa XML in un dizionario. **Esempio 1:** ``` Input: 1 Getting started with GraphQL Output (object): { "posts":{ "post":{ "id":1, "title":"Getting started with GraphQL" } } } ``` **Esempio 2:** ``` Input: 1 Getting started with GraphQL 2 Getting started with AppSync Output (JavaScript object): { "posts":{ "post":[ { "id":1, "title":"Getting started with GraphQL" }, { "id":2, "title":"Getting started with AppSync" } ] } } ``` **`util.xml.toJsonString(String, Boolean?) : String`** Converte una stringa XML in una stringa JSON. È simile a`toMap`, tranne per il fatto che l'output è una stringa. Questa funzione è utile se si desidera convertire direttamente e restituire la risposta XML da un oggetto HTTP in formato JSON. È possibile impostare un parametro booleano opzionale per determinare se si desidera codificare il JSON come stringa.