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 riferimento al modello di mappatura del resolver (VTL)
<a name="resolver-mapping-template-reference"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Le sezioni seguenti descriveranno come le operazioni di utilità possono essere utilizzate nei modelli di mappatura:
+  [Panoramica dei modelli di mappatura dei resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-overview.html): scopri di più su come funzionano i resolver. AWS AppSync
+  [Guida alla programmazione dei modelli di mappatura Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-programming-guide.html) - Scopri di più sulle strutture di dati VTL di base e sulla gestione logica.
+  [Riferimento contestuale del modello di mappatura Resolver: scopri di più sulla mappa contestuale](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html) e su come viene utilizzata nei resolver.
+  Riferimento all'utilità dei [modelli di mappatura Resolver - Scopri di più sull'utilizzo delle utilità per semplificare il codice](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-util-reference.html).
+  Riferimento al [modello di mappatura dei resolver per DynamoDB: scopri di più su come i resolver interagiscono con DynamoDB](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html).
+  [Riferimento al modello di mappatura dei resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-rds.html) per RDS - Scopri di più sulla struttura dei resolver e sulle interazioni con RDS.
+  [Riferimento al modello di mappatura del resolver per OpenSearch ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-elasticsearch.html): scopri di più sulla struttura delle richieste e delle risposte del resolver e sulle interazioni con il servizio. OpenSearch 
+  Riferimento al [modello di mappatura del resolver per Lambda](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-lambda.html): scopri di più sulla struttura di richieste e risposte del resolver e sulle interazioni con Lambda.
+  [Modello di mappatura del resolver di riferimento per EventBridge ](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-eventbridge.html): scopri di più sulla struttura delle richieste e delle risposte del resolver e sulle interazioni con. EventBridge
+  [Riferimento al modello di mappatura del resolver per l'origine dati None](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-none.html) - Scopri di più sulla struttura di richiesta e risposta del resolver e sulle interazioni con le fonti di dati NONE.
+  [Riferimento al modello di mappatura del resolver per HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-http.html): scopri di più sulla struttura di richiesta e risposta del resolver e sulle interazioni con gli endpoint HTTP.

# AWS AppSync panoramica dei modelli di mappatura dei resolver
<a name="resolver-mapping-template-reference-overview"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync consente di rispondere alle richieste GraphQL eseguendo operazioni sulle risorse. Per ogni campo GraphQL su cui si desidera eseguire una query o una mutazione, è necessario collegare un resolver per comunicare con una fonte di dati. La comunicazione avviene in genere tramite parametri o operazioni che sono unici per la fonte di dati.

I resolver sono i connettori tra GraphQL e una fonte di dati. Spiegano AWS AppSync come tradurre una richiesta GraphQL in entrata in istruzioni per l'origine dati di backend e come tradurre la risposta da tale fonte di dati in una risposta GraphQL. Sono scritte nell'[Apache Velocity Template Language (VTL)](https://velocity.apache.org/engine/1.7/user-guide.html), che accetta la richiesta come input e genera un documento JSON contenente le istruzioni per il resolver. È possibile utilizzare modelli di mappatura per istruzioni semplici, come passare argomenti dai campi GraphQL, o per istruzioni più complesse, come scorrere gli argomenti per creare un elemento prima di inserirlo in DynamoDB. 

Esistono due tipi di resolver che sfruttano i modelli di mappatura in modi leggermente diversi: AWS AppSync 
+ Risolutori di unità
+ Risolver per pipeline

## Risolver di unità
<a name="unit-resolvers"></a>

I resolver di unità sono entità autonome che includono solo un modello di richiesta e risposta. Possono essere utilizzati per operazioni semplici come elencare le voci di un'unica origine dati.
+ Modelli di richiesta: prende la richiesta in arrivo dopo l'analisi di un'operazione GraphQL e la converte in una configurazione di richiesta per l'operazione di origine dati selezionata.
+ Modelli di risposta: interpreta le risposte dalla tua fonte di dati e mappale alla forma del tipo di output del campo GraphQL.

## Resolver per pipeline
<a name="pipeline-resolvers"></a>

*I resolver Pipeline contengono una o più funzioni che vengono eseguite in ordine sequenziale.* Ogni funzione include un modello di richiesta e un modello di risposta. Un risolutore di pipeline ha anche un modello *prima* e un modello *successivo* che circondano la sequenza di funzioni contenuta nel modello. Il modello *after* è mappato al tipo di output del campo GraphQL. I resolver di pipeline differiscono dai resolver di unità nel modo in cui il modello di risposta mappa l'output. *Un pipeline resolver può mappare qualsiasi output desiderato, incluso l'input per un'altra funzione o il modello after del pipeline resolver.* 

 *Le funzioni* del resolver della pipeline consentono di scrivere una logica comune da riutilizzare su più resolver dello schema. Le funzioni sono collegate direttamente a una fonte di dati e, come un risolutore di unità, contengono lo stesso formato del modello di mappatura delle richieste e delle risposte.

Il diagramma seguente mostra il flusso di processo di un resolver di unità a sinistra e di un resolver di pipeline a destra.

![\[Un diagramma di un resolver di unità che comunica con una singola origine dati e un diagramma di un resolver di pipeline che comunica con più fonti di dati.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/unit-pipeline-resolver.png)


I resolver Pipeline contengono un superset delle funzionalità supportate dai resolver di unità e altro ancora, al costo di una maggiore complessità.

### Anatomia di un resolver di pipeline
<a name="anatomy-of-a-pipeline-resolver"></a>

**Un pipeline resolver è composto da un modello **Before** mapping, un template After mapping e un elenco di funzioni.** Ogni funzione dispone di un modello di mappatura di **richieste** e **risposte** che esegue su un'origine dati. Dal momento che delega l'esecuzione a un elenco di funzioni, il resolver di pipeline non prevede il collegamento a un'origine dati. Funzioni e resolver di unità sono primitive che eseguono un'operazione su origini dati. Per ulteriori informazioni, consulta la panoramica del [modello di mappatura Resolver](#aws-appsync-resolver-mapping-template-reference-overview).

#### Prima del modello di mappatura
<a name="before-mapping-template"></a>

Il modello di mappatura delle richieste di un risolutore di pipeline, o il passaggio **Before**, consente di eseguire una logica di preparazione prima di eseguire le funzioni definite.

#### Elenco delle funzioni
<a name="functions-list"></a>

L'elenco delle funzioni eseguite in sequenza da un resolver di pipeline. Il risultato valutato del modello di mappatura della richiesta afferente al resolver di pipeline viene reso disponibile alla prima funzione, come `$ctx.prev.result`. L'output di ogni funzione è reso disponibile per la successiva come `$ctx.prev.result`.

#### Modello di mappatura della fase successiva
<a name="after-mapping-template"></a>

Il modello di mappatura delle risposte di un risolutore di pipeline, o il passaggio **After**, consente di eseguire una logica di mappatura finale dall'output dell'ultima funzione al tipo di campo GraphQL previsto. Il risultato dell'ultima funzione in elenco è riportato nel modello di mappatura del resolver di pipeline come `$ctx.prev.result` o `$ctx.result`.

#### Flusso di esecuzione
<a name="execution-flow"></a>

Dato un resolver a pipeline composto da due funzioni, l'elenco seguente rappresenta il flusso di esecuzione quando viene richiamato il resolver:

![\[GraphQL request flow diagram showing template processing and data source interactions.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/PipelineResolver.jpg)


1. **Pipeline** resolver Prima del modello di mappatura

1. Funzione 1: modello di mappatura della richiesta di funzione

1. Funzione 1: invocazione dell'origine dati

1. Funzione 1: modello di mappatura della risposta di funzione

1. Funzione 2: modello di mappatura della richiesta di funzione

1. Funzione 2: invocazione dell'origine dati

1. Funzione 2: modello di mappatura della risposta di funzione

1. **Pipeline resolver Dopo il modello di mappatura**

**Nota**  
Il flusso di esecuzione del resolver di pipeline è unidirezionale e definito staticamente sul resolver.

#### Utili utilità Apache Velocity Template Language (VTL)
<a name="useful-apache-velocity-template-language-vtl-utilities"></a>

In fase di sviluppo, al crescere della complessità di un'applicazione, possono tornare utili direttive, comandi e funzionalità di VTL. Nell'utilizzo dei resolver di pipeline, è possibile avvalersi delle seguenti funzionalità.

##### \$1ctx.stash
<a name="ctx-stash"></a>

Lo stash è reso disponibile all'interno di `Map` ogni resolver e modello di mappatura delle funzioni. La sua istanza viene attivata dall'esecuzione del resolver. Ciò significa che permette di trasferire arbitrariamente i dati tra i modelli di mappatura della richiesta e della risposta e tra le funzioni di un resolver di pipeline. [Lo stash espone gli stessi metodi della struttura dati della mappa Java.](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html)

##### \$1ctx.prev.result
<a name="ctx-prev-result"></a>

`$ctx.prev.result`Rappresenta il risultato dell'operazione precedente eseguita nel resolver della pipeline.

Se l'operazione precedente era il modello Before mapping del risolutore di pipeline, allora `$ctx.prev.result` rappresenta l'output della valutazione del modello e viene reso disponibile per la prima funzione nella pipeline. Se l'operazione precedente corrisponde alla prima funzione, `$ctx.prev.result` è l'output della prima funzione, disponibile per la seconda funzione della pipeline. Se l'operazione precedente era l'ultima funzione, `$ctx.prev.result` rappresenta l'output dell'ultima funzione e viene resa disponibile al modello After mapping del risolutore di pipeline.

##### \$1return(data: Object)
<a name="return-data-object"></a>

La direttiva `#return(data: Object)` torna utile se occorre uscire prematuramente da un modello di mappatura. `#return(data: Object)`, come la parola chiave *return* dei linguaggi di programmazione, restituisce dati ed esce dal più recente blocco definito di operazioni logiche. Se utilizzato all'interno di un modello di mappatura del resolver, quindi, `#return` esce dal resolver. L'utilizzo di `#return(data: Object)` in un modello di mappatura del resolver prevede l'impostazione di `data` sul campo GraphQL. L'utilizzo di `#return(data: Object)` da un modello di mappatura della funzione prevede l'uscita dalla funzione corrente e l'esecuzione della successiva nella pipeline o del modello di mappatura della risposta del resolver.

##### \$1return
<a name="return"></a>

È uguale a`#return(data: Object)`, ma `null` verrà restituito al suo posto.

##### \$1util.error
<a name="util-error"></a>

Con `$util.error` è possibile generare un errore di campo. Utilizzando `$util.error` all'interno di un modello di mappatura della funzione, è possibile generare immediatamente un errore di campo e, quindi, bloccare l'esecuzione delle funzioni successive. Per maggiori dettagli e altre `$util.error` firme, visita il riferimento all'utilità per i modelli di [mappatura Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).

##### \$1util.appendError
<a name="util-appenderror"></a>

`$util.appendError`, per quanto molto simile a `$util.error()`, non interrompe la valutazione del modello di mappatura. Al contrario, segnala che si è verificato un errore con il campo, ma consente al modello di essere valutato e, di conseguenza, di restituire i dati. L'utilizzo di `$util.appendError` all'interno di una funzione non interrompe il flusso di esecuzione della pipeline. Per maggiori dettagli e altre `$util.error` firme, visita il riferimento all'utilità per i modelli di mappatura [Resolver](resolver-util-reference.md#aws-appsync-resolver-mapping-template-util-reference).

## Modello di esempio
<a name="example-template"></a>

Supponiamo di avere un'origine dati DynamoDB e un resolver Unit su **un** campo `getPost(id:ID!)` denominato che restituisce un `Post` tipo con la seguente query GraphQL:

```
getPost(id:1){
    id
    title
    content
}
```

Il modello di resolver potrebbe essere simile a quanto segue:

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}
```

In questo modo si sostituisce il valore del parametro di input `id`di `1` con `${ctx.args.id}` e si genera il JSON seguente:

```
{
    "version" : "2018-05-29",
    "operation" : "GetItem",
    "key" : {
        "id" : { "S" : "1" }
    }
}
```

AWS AppSync utilizza questo modello per generare istruzioni per comunicare con DynamoDB e ottenere dati (o eseguire altre operazioni a seconda dei casi). Dopo aver restituito i dati, AWS AppSync li esegue tramite un modello di mappatura della risposta opzionale, che è possibile usare per eseguire il modellamento dei dati o la logica. Ad esempio, quando riceviamo i risultati da DynamoDB, potrebbero assomigliare a questo:

```
{
        "id" : 1,
        "theTitle" : "AWS AppSync works offline!",
        "theContent-part1" : "It also has realtime functionality",
        "theContent-part2" : "using GraphQL"
}
```

È possibile scegliere di unire due dei campi in un unico campo con il seguente modello di mappatura della risposta:

```
{
        "id" : $util.toJson($context.data.id),
        "title" : $util.toJson($context.data.theTitle),
        "content" : $util.toJson("${context.data.theContent-part1} ${context.data.theContent-part2}")
}
```

Ecco il modo in cui vengono modellati i dati dopo che a essi viene applicato il modello:

```
{
        "id" : 1,
        "title" : "AWS AppSync works offline!",
        "content" : "It also has realtime functionality using GraphQL"
}
```

Questi dati vengono restituiti come risposta a un client nel seguente modo:

```
{
        "data": {
                "getPost":      {
                        "id" : 1,
                        "title" : "AWS AppSync works offline!",
                        "content" : "It also has realtime functionality using GraphQL"
                }
        }
}
```

Si noti che nella maggior parte dei casi, i modelli di mappatura di risposta sono un semplice passthrough di dati, per lo più divergenti se si restituisce un singolo elemento o un elenco di elementi. Per un singolo elemento il passthrough è:

```
$util.toJson($context.result)
```

Per elenchi il passthrough è in genere:

```
$util.toJson($context.result.items)
```

[Per vedere altri esempi di resolver di unità e pipeline, consulta i tutorial di Resolver.](tutorials.md#aws-appsync-tutorials)

## Regole di deserializzazione dei modelli di mappatura valutate
<a name="evaluated-mapping-template-deserialization-rules"></a>

I modelli di mappatura vengono valutati in una stringa. In AWS AppSync, la stringa di output deve seguire una struttura JSON per essere valida.

Inoltre, vengono applicate le seguenti regole di deserializzazione.

### Le chiavi duplicate non sono consentite negli oggetti JSON
<a name="duplicate-keys-are-not-allowed-in-json-objects"></a>

Se la stringa del modello di mappatura valutata rappresenta un oggetto JSON o contiene un oggetto con chiavi duplicate, il modello di mapping restituisce il seguente messaggio di errore:

 `Duplicate field 'aField' detected on Object. Duplicate JSON keys are not allowed.` 

Esempio di una chiave duplicata in un modello di mapping delle richieste valutate:

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
        "field": "getPost" ## key 'field' has been redefined
    }
}
```

Per correggere questo errore, non ridefinire le chiavi negli oggetti JSON.

### I caratteri finali non sono consentiti negli oggetti JSON
<a name="trailing-characters-are-not-allowed-in-json-objects"></a>

Se la stringa del modello di mappatura valutata rappresenta un oggetto JSON e contiene caratteri estranei finali, il modello di mapping restituisce il seguente messaggio di errore:

 `Trailing characters at the end of the JSON string are not allowed.` 

Esempio di caratteri finali in un modello di mappatura delle richieste valutate:

```
{
    "version": "2018-05-29",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "1",
    }
}extraneouschars
```

Per correggere questo errore, assicurati che i modelli valutati valutino rigorosamente JSON.

# AWS AppSync guida alla programmazione dei modelli di mappatura dei resolver
<a name="resolver-mapping-template-reference-programming-guide"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Questo è un tutorial in stile libro di cucina sulla programmazione con l'Apache Velocity Template Language (VTL) in. AWS AppSync Se conosci altri linguaggi di programmazione come C o Java JavaScript, dovrebbe essere abbastanza semplice.

AWS AppSync utilizza VTL per tradurre le richieste GraphQL dei client in una richiesta alla fonte dati. Inverte quindi il processo per tradurre la risposta dell'origine dati in risposta GraphQL. VTL è un linguaggio di template logico che consente di manipolare sia la richiesta che la risposta nel request/response flusso standard di un'applicazione Web, utilizzando tecniche come:
+ Valori predefiniti per nuove voci
+ Convalida e formattazione dell'input
+ Trasformazione e modellazione dei dati
+ Iterazione su elenchi, mappe e matrici per ottenere o modificare i valori
+ Applicazione di filtri/modifiche alle risposte in base all'identità dell'utente
+ Verifiche dell'autorizzazione complesse

Ad esempio, potresti voler eseguire una convalida del numero di telefono nel servizio su un argomento GraphQL o convertire un parametro di input in lettere maiuscole prima di archiviarlo in DynamoDB. Oppure potresti volere che i sistemi client forniscano un codice, come parte di un argomento GraphQL, un'attestazione di un token JWT o un'intestazione HTTP, e che rispondano con dati solo se il codice restituisce una stringa specifica in un elenco. Questi sono tutti controlli logici che è possibile eseguire con VTL in. AWS AppSync

Con VTL puoi applicare la logica tramite tecniche di programmazione che possono risultarti familiari. Tuttavia, è limitato all'esecuzione all'interno del request/response flusso standard per garantire che l'API GraphQL sia scalabile man mano che la base di utenti cresce. Poiché supporta AWS AppSync anche AWS Lambda come resolver, puoi scrivere funzioni Lambda nel tuo linguaggio di programmazione preferito (Node.js, Python, Go, Java, ecc.) se hai bisogno di maggiore flessibilità.

## Configurazione
<a name="setup"></a>

Una tecnica comune per l'apprendimento di una lingua consiste nel stampare i risultati (ad esempio, `console.log(variable)` in JavaScript) per vedere cosa succede. In questo tutorial mostreremo questa tecnica creando un semplice schema GraphQL e passando una mappa di valori a una funzione Lambda. La funzione Lambda stampa i valori e quindi risponde con questi. Ciò ti consentirà di comprendere il request/response flusso e vedere diverse tecniche di programmazione.

Per iniziare, crea lo schema GraphQL seguente:

```
type Query {
    get(id: ID, meta: String): Thing
}

type Thing {
    id: ID!
    title: String!
    meta: String
}

schema {
    query: Query
}
```

Ora create la seguente AWS Lambda funzione, usando Node.js come linguaggio:

```
exports.handler = (event, context, callback) => {
    console.log('VTL details: ', event);
    callback(null, event);
};
```

Nel riquadro **Fonti dati** della AWS AppSync console, aggiungi questa funzione Lambda come nuova origine dati. Torna alla pagina **Schema** della console e fai clic sul pulsante **ATTACH (COLLEGA)** a destra, accanto alla query `get(...):Thing`. Per il modello di richiesta, scegli il modello esistente dal menu **Invoke and forward arguments (Richiama e inoltra argomenti)**. Per il modello di risposta, scegli **Return Lambda result (Restituisci risultato Lambda)**.

Apri Amazon CloudWatch Logs per la tua funzione Lambda in un'unica posizione e, dalla scheda Queries **della** console, esegui AWS AppSync la seguente query GraphQL:

```
query test {
  get(id:123 meta:"testing"){
    id
    meta
  }
}
```

La risposta GraphQL deve contenere `id:123` e `meta:testing`, perché la funzione Lambda ne esegue di nuovo l'echoing. Dopo alcuni secondi, dovresti vedere anche un record in CloudWatch Logs con questi dettagli.

## Variabili
<a name="variables"></a>

VTL usa [riferimenti](https://velocity.apache.org/engine/1.7/user-guide.html#references) per archiviare o manipolare i dati. Esistono tre tipi di riferimenti in VTL: variabili, proprietà e metodi. Le variabili hanno un carattere `$` all'inizio e vengono create con la direttiva `#set`:

```
#set($var = "a string")
```

Nelle variabili sono archiviati tipi simili di altri linguaggi con cui hai familiarità, ad esempio numeri, stringhe, matrici, elenchi e mappe. Potrai notare un payload JSON inviato nel modello di richiesta predefinito per i resolver Lambda:

```
"payload": $util.toJson($context.arguments)
```

Un paio di cose da notare qui: in primo luogo, AWS AppSync offre diverse funzioni utili per le operazioni comuni. In questo esempio `$util.toJson` converte una variabile in JSON. In secondo luogo, la variabile `$context.arguments` viene popolata automaticamente da una richiesta GraphQL come oggetto mappa. Puoi creare una nuova mappa in questo modo:

```
#set( $myMap = {
  "id": $context.arguments.id,
  "meta": "stuff",
  "upperMeta" : $context.arguments.meta.toUpperCase()
} )
```

Hai ora creato una variabile denominata `$myMap`, che include le chiavi `id`, `meta` e `upperMeta`. Si verifica anche quanto segue:
+  `id` viene popolato con una chiave dagli argomenti GraphQL. Questo è un comportamento comune in VTL per recuperare argomenti dai client.
+  `meta` è codificato con un valore e mostra valori predefiniti.
+  `upperMeta` sta trasformando l'argomento `meta` tramite un metodo `.toUpperCase()`.

Inserisci il codice precedente all'inizio del modello di richiesta e modifica `payload` in modo da usare la nuova variabile `$myMap`:

```
"payload": $util.toJson($myMap)
```

Esegui la tua funzione Lambda e puoi vedere la modifica della risposta e questi dati nei CloudWatch log. Man mano che procediamo nelle altre fasi di questo tutorial, continueremo a popolare `$myMap` per permetterti di eseguire test simili.

Puoi anche impostare *proprietà* nelle variabili. Queste possono essere semplici stringhe, matrici o JSON:

```
#set($myMap.myProperty = "ABC")
#set($myMap.arrProperty = ["Write", "Some", "GraphQL"])
#set($myMap.jsonProperty = {
    "AppSync" : "Offline and Realtime",
    "Cognito" : "AuthN and AuthZ"
})
```

### Riferimenti silenziosi
<a name="quiet-references"></a>

Poiché VTL è un linguaggio di creazione di modelli, per impostazione predefinita ogni riferimento specificato restituisce `.toString()`. Se il riferimento non è definito, viene stampata l'effettiva rappresentazione del riferimento, come stringa. Esempio:

```
#set($myValue = 5)
##Prints '5'
$myValue

##Prints '$somethingelse'
$somethingelse
```

Per risolvere questo problema, VTL ha una sintassi di *riferimento invisibile* o *riferimento silenzioso*, che indica il motore del modello per sopprimere questo comportamento. La sintassi è `$!{}`. Ad esempio, se abbiamo leggermente modificato il codice precedente in modo da usare `$!{somethingelse}`, la stampa sarà annullata:

```
#set($myValue = 5)
##Prints '5'
$myValue

##Nothing prints out
$!{somethingelse}
```

## Metodi di chiamata
<a name="calling-methods"></a>

In un esempio precedente, abbiamo dimostrato come creare una variabile e contemporaneamente impostare valori. Ciò può essere eseguito in due passaggi, aggiungendo dati alla mappa come illustrato di seguito:

```
#set ($myMap = {})
#set ($myList = [])

##Nothing prints out
$!{myMap.put("id", "first value")}
##Prints "first value"
$!{myMap.put("id", "another value")}
##Prints true
$!{myList.add("something")}
```

 **TUTTAVIA**, devi tenere conto di un paio di considerazioni riguardo a questo approccio. Benché la notazione `$!{}` per i riferimenti invisibili permetta di chiamare metodi, come mostrato sopra, non eliminerà il valore restituito del metodo eseguito. Ecco perché nell'esempio sopra abbiamo osservato `##Prints "first value"` e `##Prints true`. In questo caso, possono verificarsi errori quando esegui l'iterazione di mappe o elenchi, ad esempio inserendo un valore quando esiste già una chiave, perché l'output aggiunge stringhe impreviste al modello in fase di valutazione.

La soluzione alternativa a questo problema consiste a volte nel chiamare i metodi usando una direttiva `#set` e ignorando la variabile. Esempio:

```
#set ($myMap = {})
#set($discard = $myMap.put("id", "first value"))
```

È possibile utilizzare questa tecnica nei modelli, in quanto impedisce la stampa di stringhe impreviste nel modello. AWS AppSync fornisce una comoda funzione alternativa che offre lo stesso comportamento in una notazione più succinta. In questo modo, puoi ignorare queste specifiche di implementazione. Puoi accedere a questa funzione in `$util.quiet()` o nel relativo alias `$util.qr()`. Esempio:

```
#set ($myMap = {})
#set ($myList = [])

##Nothing prints out
$util.quiet($myMap.put("id", "first value"))
##Nothing prints out
$util.qr($myList.add("something"))
```

## Stringhe
<a name="strings"></a>

Come per tutti i linguaggi di programmazione, le stringhe possono essere difficili da gestire, in particolare quando vuoi crearle da variabili. VTL ha alcuni aspetti comuni.

Supponiamo di inserire dati come stringa in un'origine dati come DynamoDB, ma che siano compilati da una variabile, come un argomento GraphQL. Una stringa avrà virgolette doppie e per fare riferimento alla variabile in una stringa dovrai immettere semplicemente `"${}"` (e non `!` come per la [notazione dei riferimenti invisibili](https://velocity.apache.org/engine/1.7/user-guide.html#quiet-reference-notation)). [È simile a un modello letterale in: https://developer.mozilla. JavaScript org/en-US/docs/Web/JavaScript/Reference/Template\$1letterali](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) 

```
#set($firstname = "Jeff")
$!{myMap.put("Firstname", "${firstname}")}
```

È possibile vederlo nei modelli di richiesta DynamoDB, ad `"author": { "S" : "${context.arguments.author}"}` esempio quando si utilizzano argomenti dei client GraphQL o per la generazione automatica di ID come. `"id" : { "S" : "$util.autoId()"}` Di conseguenza, puoi fare riferimento a una variabile o al risultato di un metodo all'interno di una stringa per immettere i dati.

Puoi anche usare metodi pubblici della classe [String](https://docs.oracle.com/javase/6/docs/api/java/lang/String.html) Java, ad esempio per l'estrazione di una sottostringa:

```
#set($bigstring = "This is a long string, I want to pull out everything after the comma")
#set ($comma = $bigstring.indexOf(','))
#set ($comma = $comma +2)
#set ($substring = $bigstring.substring($comma))

$util.qr($myMap.put("substring", "${substring}"))
```

Anche la concatenazione di stringhe è un'attività molto comune. Puoi eseguirla solo con riferimenti di variabile o con valori statici:

```
#set($s1 = "Hello")
#set($s2 = " World")

$util.qr($myMap.put("concat","$s1$s2"))
$util.qr($myMap.put("concat2","Second $s1 World"))
```

## Loop
<a name="loops"></a>

Dopo avere creato variabili e chiamato metodi, puoi ora aggiungere la logica al codice. A differenza di altri linguaggi, VTL permette solo loop, in cui il numero di iterazioni è predeterminato. Velocity non include `do..while`. Questa progettazione garantisce che il processo di valutazione termini sempre e fornisce limiti di scalabilità durante l'esecuzione delle operazioni GraphQL.

I loop vengono creati con `#foreach` e richiedono che venga specificata una **variabile di loop** e un **oggetto iterabile** , ad esempio una matrice, un elenco, una mappa o una raccolta. Un classico esempio di programmazione con un loop `#foreach` è l'esecuzione di un loop di voci in una raccolta e la rispettiva stampa. Di conseguenza, in questo caso recupereremo le voci e quindi le aggiungeremo alla mappa:

```
#set($start = 0)
#set($end = 5)
#set($range = [$start..$end])

#foreach($i in $range)
   ##$util.qr($myMap.put($i, "abc"))
   ##$util.qr($myMap.put($i, $i.toString()+"foo")) ##Concat variable with string
   $util.qr($myMap.put($i, "${i}foo"))     ##Reference a variable in a string with "${varname}"
#end
```

Questo esempio mostra un paio di caratteristiche. La prima è l'uso di variabili con l'operatore di intervallo `[..]` per creare un oggetto iterabile. Quindi ogni voce viene referenziata da una variabile `$i` che puoi usare. Nell'esempio precedente noterai anche che i **commenti** sono contrassegnati da un doppio simbolo di cancelletto `##`. Questo mostra anche l'uso della variabile di loop in entrambi i valori o chiavi, nonché metodi diversi di concatenazione tramite stringhe.

Poiché `$i` è un valore intero, puoi chiamare un metodo `.toString()`. Questa scelta può rivelarsi utile per i tipi GraphQL INT.

Puoi anche usare un operatore di intervallo direttamente, ad esempio:

```
#foreach($item in [1..5])
    ...
#end
```

## Matrici
<a name="arrays"></a>

Fino a questo punto, hai usato una mappa, ma anche le matrici sono comuni in VTL. Con le matrici, hai anche accesso ad alcuni metodo sottostanti, tra cui `.isEmpty()`, `.size()`, `.set()`, `.get()` e `.add()`, mostrati di seguito:

```
#set($array = [])
#set($idx = 0)

##adding elements
$util.qr($array.add("element in array"))
$util.qr($myMap.put("array", $array[$idx]))

##initialize array vals on create
#set($arr2 = [42, "a string", 21, "test"])

$util.qr($myMap.put("arr2", $arr2[$idx]))
$util.qr($myMap.put("isEmpty", $array.isEmpty()))  ##isEmpty == false
$util.qr($myMap.put("size", $array.size()))

##Get and set items in an array
$util.qr($myMap.put("set", $array.set(0, 'changing array value')))
$util.qr($myMap.put("get", $array.get(0)))
```

L'esempio precedente utilizzava la notazione dell'indice di matrice per recuperare un elemento con. `arr2[$idx]` Puoi cercare per nome da a Map/dictionary in un modo simile:

```
#set($result = {
    "Author" : "Nadia",
    "Topic" : "GraphQL"
})

$util.qr($myMap.put("Author", $result["Author"]))
```

Questo approccio è molto comune quando filtri i risultati restituiti da origini dati nei modelli di risposta usando condizionali.

## Controlli condizionali
<a name="conditional-checks"></a>

La sezione precedente con `#foreach` ha mostrato alcuni esempi dell'uso di logica per trasformare dati con VTL. Puoi anche applicare controlli condizionali per valutare i dati in fase di esecuzione:

```
#if(!$array.isEmpty())
    $util.qr($myMap.put("ifCheck", "Array not empty"))
#else
    $util.qr($myMap.put("ifCheck", "Your array is empty"))
#end
```

Il controllo `#if()` di un'espressione booleana mostrato sopra è valido, ma puoi anche usare operatori e `#elseif()` per la definizione di diramazioni:

```
#if ($arr2.size() == 0)
    $util.qr($myMap.put("elseIfCheck", "You forgot to put anything into this array!"))
#elseif ($arr2.size() == 1)
    $util.qr($myMap.put("elseIfCheck", "Good start but please add more stuff"))
#else
    $util.qr($myMap.put("elseIfCheck", "Good job!"))
#end
```

Questi due esempi hanno mostrato una negazione (\$1) e un'uguaglianza (==). Possiamo usare anche \$1\$1, &&, >, <, >=, <= e \$1=.

```
#set($T = true)
#set($F = false)

#if ($T || $F)
  $util.qr($myMap.put("OR", "TRUE"))
#end

#if ($T && $F)
  $util.qr($myMap.put("AND", "TRUE"))
#end
```

 **Nota:** solo `Boolean.FALSE` e `null` sono considerati valori false nei condizionali. Zero (0) e le stringhe vuote ("") non equivalgono a false.

## Operatori
<a name="operators"></a>

Nessun linguaggio di programmazione sarebbe completo senza alcuni operatori per l'esecuzione di operazioni matematiche. Ecco alcuni esempi per iniziare:

```
#set($x = 5)
#set($y = 7)
#set($z = $x + $y)
#set($x-y = $x - $y)
#set($xy = $x * $y)
#set($xDIVy = $x / $y)
#set($xMODy = $x % $y)

$util.qr($myMap.put("z", $z))
$util.qr($myMap.put("x-y", $x-y))
$util.qr($myMap.put("x*y", $xy))
$util.qr($myMap.put("x/y", $xDIVy))
$util.qr($myMap.put("x|y", $xMODy))
```

### Utilizzo congiunto di loop e condizionali
<a name="loops-and-conditionals-together"></a>

È prassi molto comune per trasformare dati in VTL, ad esempio prima di scrivere o leggere in un'origine dati, eseguire un loop degli oggetti e quindi eseguire controlli prima di un'operazione. La combinazione di alcuni degli strumenti mostrati nelle sezioni precedenti offre molte funzionalità. Un'informazione utile di cui tenere conto è che `#foreach` fornisce automaticamente un oggetto `.count` in ogni voce:

```
#foreach ($item in $arr2)
  #set($idx = "item" + $foreach.count)
  $util.qr($myMap.put($idx, $item))
#end
```

Ad esempio, se vuoi semplicemente recuperare valori da una mappa al di sotto di una determinata dimensione. L'uso del conteggio insieme a condizionali e all'istruzione `#break` ti permette di eseguire questa operazione:

```
#set($hashmap = {
  "DynamoDB" : "https://aws.amazon.com/dynamodb/",
  "Amplify" : "https://github.com/aws/aws-amplify",
  "DynamoDB2" : "https://aws.amazon.com/dynamodb/",
  "Amplify2" : "https://github.com/aws/aws-amplify"
})

#foreach ($key in $hashmap.keySet())
    #if($foreach.count > 2)
    #break
  #end
    $util.qr($myMap.put($key, $hashmap.get($key)))
#end
```

Il loop `#foreach` precedente viene iterato con `.keySet()`, che puoi usare nelle mappe. In questo modo, puoi accedere per ottenere `$key` e fare riferimento al valore con `.get($key)`. Gli argomenti GraphQL dei client in AWS AppSync vengono archiviati come mappa. Inoltre possono essere iterati tramite `.entrySet()`, che ti permette quindi di accedere a entrambi i valori e le chiavi come Set e popolare altre variabili o eseguire controlli condizionali complessi, come la convalida o la trasformazione dell'input:

```
#foreach( $entry in $context.arguments.entrySet() )
#if ($entry.key == "XYZ" && $entry.value == "BAD")
    #set($myvar = "...")
  #else
    #break
  #end
#end
```

Altri esempi comuni sono l'inserimento automatico di informazioni predefinite, come le versioni iniziali degli oggetti durante la sincronizzazione dei dati (molto importante nella risoluzione dei conflitti) o il proprietario predefinito di un oggetto per i controlli di autorizzazione. Mary ha creato questo post sul blog, quindi:

```
#set($myMap.owner ="Mary")
#set($myMap.defaultOwners = ["Admins", "Editors"])
```

## Contesto
<a name="context"></a>

Ora che conosci meglio l'esecuzione di controlli logici nei AWS AppSync resolver con VTL, dai un'occhiata all'oggetto context:

```
$util.qr($myMap.put("context", $context))
```

Questo oggetto contiene tutte le informazioni cui puoi accedere nella richiesta GraphQL. Per una spiegazione dettagliata, consulta le [informazioni di riferimento sull'oggetto](resolver-context-reference.md#aws-appsync-resolver-mapping-template-context-reference).

## Filtraggio
<a name="filtering"></a>

Finora in questo tutorial tutte le informazioni provenienti dalla funzione Lambda sono state restituite alla query GraphQL con una trasformazione JSON molto semplice:

```
$util.toJson($context.result)
```

La logica VTL è altrettanto efficace quando ottieni risposte da un'origine dati, in particolare quando esegui verifiche delle autorizzazioni sulle risorse. Osserviamo alcuni esempi. Prima di tutto, prova a modificare il modello di risposta in questo modo:

```
#set($data = {
    "id" : "456",
    "meta" : "Valid Response"
})

$util.toJson($data)
```

Indipendentemente da quanto avviene con l'operazione GraphQL, al client vengono restituiti valori hardcoded. Puoi modificare leggermente questo comportamento in modo che il campo `meta` venga popolato dalla risposta Lambda, impostata in precedenza nel tutorial nel valore `elseIfCheck` quando abbiamo presentato i condizionali:

```
#set($data = {
    "id" : "456"
})

#foreach($item in $context.result.entrySet())
    #if($item.key == "elseIfCheck")
        $util.qr($data.put("meta", $item.value))
    #end
#end

$util.toJson($data)
```

 Poiché `$context.result` è una mappa, puoi usare `entrySet()` per eseguire la logica su uno dei valori o delle chiavi restituiti. Poiché `$context.identity` contiene informazioni sull'utente che ha eseguito l'operazione GraphQL, se restituisci informazioni di autorizzazione dall'origine dati, puoi scegliere di restituire a un utente tutti i dati, alcuni o nessuno in base alla logica. Modifica il modello di risposta in modo che sia simile al seguente:

```
#if($context.result["id"] == 123)
    $util.toJson($context.result)
  #else
    $util.unauthorized()
#end
```

Se esegui la query GraphQL, i dati verranno restituiti normalmente. Tuttavia, se modifichi l'argomento id in un valore diverso da 123 (`query test { get(id:456 meta:"badrequest"){} }`), riceverai un messaggio di autorizzazione non concessa.

Puoi trovare altri esempi di scenari di autorizzazione nella sezione dei [casi d'uso di autorizzazione](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases).

### Esempio di modello
<a name="appendix-template-sample"></a>

Se hai seguito interamente il tutorial, avrai creato questo modello passo dopo passo. Se non lo hai fatto, lo includiamo di seguito per copiarlo per il test.

 **Modello di richiesta** 

```
#set( $myMap = {
  "id": $context.arguments.id,
  "meta": "stuff",
  "upperMeta" : "$context.arguments.meta.toUpperCase()"
} )

##This is how you would do it in two steps with a "quiet reference" and you can use it for invoking methods, such as .put() to add items to a Map
#set ($myMap2 = {})
$util.qr($myMap2.put("id", "first value"))

## Properties are created with a dot notation
#set($myMap.myProperty = "ABC")
#set($myMap.arrProperty = ["Write", "Some", "GraphQL"])
#set($myMap.jsonProperty = {
    "AppSync" : "Offline and Realtime",
    "Cognito" : "AuthN and AuthZ"
})

##When you are inside a string and just have ${} without ! it means stuff inside curly braces are a reference
#set($firstname = "Jeff")
$util.qr($myMap.put("Firstname", "${firstname}"))

#set($bigstring = "This is a long string, I want to pull out everything after the comma")
#set ($comma = $bigstring.indexOf(','))
#set ($comma = $comma +2)
#set ($substring = $bigstring.substring($comma))
$util.qr($myMap.put("substring", "${substring}"))

##Classic for-each loop over N items:
#set($start = 0)
#set($end = 5)
#set($range = [$start..$end])
#foreach($i in $range)          ##Can also use range operator directly like #foreach($item in [1...5])
   ##$util.qr($myMap.put($i, "abc"))
   ##$util.qr($myMap.put($i, $i.toString()+"foo")) ##Concat variable with string
   $util.qr($myMap.put($i, "${i}foo"))     ##Reference a variable in a string with "${varname)"
#end

##Operators don't work
#set($x = 5)
#set($y = 7)
#set($z = $x + $y)
#set($x-y = $x - $y)
#set($xy = $x * $y)
#set($xDIVy = $x / $y)
#set($xMODy = $x % $y)
$util.qr($myMap.put("z", $z))
$util.qr($myMap.put("x-y", $x-y))
$util.qr($myMap.put("x*y", $xy))
$util.qr($myMap.put("x/y", $xDIVy))
$util.qr($myMap.put("x|y", $xMODy))

##arrays
#set($array = ["first"])
#set($idx = 0)
$util.qr($myMap.put("array", $array[$idx]))
##initialize array vals on create
#set($arr2 = [42, "a string", 21, "test"])
$util.qr($myMap.put("arr2", $arr2[$idx]))
$util.qr($myMap.put("isEmpty", $array.isEmpty()))  ##Returns false
$util.qr($myMap.put("size", $array.size()))
##Get and set items in an array
$util.qr($myMap.put("set", $array.set(0, 'changing array value')))
$util.qr($myMap.put("get", $array.get(0)))

##Lookup by name from a Map/dictionary in a similar way:
#set($result = {
    "Author" : "Nadia",
    "Topic" : "GraphQL"
})
$util.qr($myMap.put("Author", $result["Author"]))


##Conditional examples
#if(!$array.isEmpty())
$util.qr($myMap.put("ifCheck", "Array not empty"))
#else
$util.qr($myMap.put("ifCheck", "Your array is empty"))
#end

#if ($arr2.size() == 0)
$util.qr($myMap.put("elseIfCheck", "You forgot to put anything into this array!"))
#elseif ($arr2.size() == 1)
$util.qr($myMap.put("elseIfCheck", "Good start but please add more stuff"))
#else
$util.qr($myMap.put("elseIfCheck", "Good job!"))
#end

##Above showed negation(!) and equality (==), we can also use OR, AND, >, <, >=, <=, and !=
#set($T = true)
#set($F = false)
#if ($T || $F)
  $util.qr($myMap.put("OR", "TRUE"))
#end

#if ($T && $F)
  $util.qr($myMap.put("AND", "TRUE"))
#end

##Using the foreach loop counter - $foreach.count
#foreach ($item in $arr2)
  #set($idx = "item" + $foreach.count)
  $util.qr($myMap.put($idx, $item))
#end

##Using a Map and plucking out keys/vals
#set($hashmap = {
    "DynamoDB" : "https://aws.amazon.com/dynamodb/",
    "Amplify" : "https://github.com/aws/aws-amplify",
    "DynamoDB2" : "https://aws.amazon.com/dynamodb/",
    "Amplify2" : "https://github.com/aws/aws-amplify"
})

#foreach ($key in $hashmap.keySet())
    #if($foreach.count > 2)
        #break
    #end
    $util.qr($myMap.put($key, $hashmap.get($key)))
#end

##concatenate strings
#set($s1 = "Hello")
#set($s2 = " World")
$util.qr($myMap.put("concat","$s1$s2"))
$util.qr($myMap.put("concat2","Second $s1 World"))

$util.qr($myMap.put("context", $context))

{
    "version" : "2017-02-28",
    "operation": "Invoke",
    "payload": $util.toJson($myMap)
}
```

 **Modello di risposta** 

```
#set($data = {
"id" : "456"
})
#foreach($item in $context.result.entrySet())   ##$context.result is a MAP so we use entrySet()
    #if($item.key == "ifCheck")
        $util.qr($data.put("meta", "$item.value"))
    #end
#end

##Uncomment this out if you want to test and remove the below #if check
##$util.toJson($data)

#if($context.result["id"] == 123)
    $util.toJson($context.result)
  #else
    $util.unauthorized()
#end
```

# AWS AppSync riferimento al contesto del modello di mappatura del resolver
<a name="resolver-context-reference"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync definisce un insieme di variabili e funzioni per lavorare con i modelli di mappatura dei resolver. Ciò semplifica le operazioni logiche sui dati con GraphQL. Questo documento descrive queste funzioni e offre alcuni esempi per l'uso dei modelli.

## Accesso a `$context`
<a name="accessing-the-context"></a>

La variabile `$context` è una mappa contenente tutte le informazioni contestuali per la chiamata del resolver. Ha la struttura seguente:

```
{
   "arguments" : { ... },
   "source" : { ... },
   "result" : { ... },
   "identity" : { ... },
   "request" : { ... },
   "info": { ... }
}
```

**Nota**  
Se state cercando di accedere a una dictionary/map voce (ad esempio una voce in`context`) utilizzando la relativa chiave per recuperare il valore, il Velocity Template Language (VTL) consente di utilizzare direttamente la notazione. `<dictionary-element>.<key-name>` Tuttavia, questo potrebbe non funzionare per tutti i casi, ad esempio quando i nomi di chiavi dispongono di caratteri speciali (per esempio, un segno di sottolineatura "\$1"). Ti consigliamo di utilizzare sempre una notazione `<dictionary-element>.get("<key-name>")`.

Ogni campo nella mappa `$context` è definito nel modo seguente:

### `$context` campi
<a name="accessing-the-context-list"></a>

** `arguments` **  
Una mappa contenente tutti gli argomenti GraphQL per questo campo.

** `identity` **  
Un oggetto contenente le informazioni sul chiamante. Vedi [Identità](#aws-appsync-resolver-context-reference-identity) per ulteriori informazioni sulla struttura di questo campo.

** `source` **  
Una mappa contenente la risoluzione del campo padre.

** `stash` **  
Lo stash è una mappa disponibile all'interno di ogni modello di mappatura di funzione o resolver. La sua istanza viene attivata dall'esecuzione del resolver. Ciò significa che è possibile trasferire arbitrariamente i dati tra i modelli di mappatura della richiesta e della risposta e tra le funzioni di un resolver di pipeline. Lo stash ammette gli stessi metodi previsti dalla struttura di dati di una [mappa Java](https://docs.oracle.com/javase/8/docs/api/java/util/Map.html).

** `result` **  
Un container per i risultati di questo resolver. Questo campo è disponibile solo per i modelli di mappatura delle risposte.  
Ad esempio, se stai risolvendo il `author` campo della seguente query:  

```
query {
    getPost(id: 1234) {
        postId
        title
        content
        author {
            id
            name
        }
    }
}
```
La variabile `$context` completa disponibile durante l'elaborazione di un modello di mappatura della risposta potrebbe essere:  

```
{
  "arguments" : {
    id: "1234"
  },
  "source": {},
  "result" : {
      "postId": "1234",
      "title": "Some title",
      "content": "Some content",
      "author": {
        "id": "5678",
        "name": "Author Name"
      }
  },
  "identity" : {
      "sourceIp" : ["x.x.x.x"],
      "userArn" : "arn:aws:iam::123456789012:user/appsync",
      "accountId" : "666666666666",
      "user" : "AIDAAAAAAAAAAAAAAAAAA"
  }
}
```

** `prev.result` **  
Il risultato di qualsiasi operazione precedente sia stata eseguita in un resolver di pipeline.  
Se l'operazione precedente era il modello Before mapping del risolutore di pipeline, allora `$ctx.prev.result` rappresenta l'output della valutazione del modello e viene reso disponibile per la prima funzione nella pipeline.  
Se l'operazione precedente corrisponde alla prima funzione, `$ctx.prev.result` è l'output della prima funzione, disponibile per la seconda funzione della pipeline.  
Se l'operazione precedente era l'ultima funzione, `$ctx.prev.result` rappresenta l'output dell'ultima funzione e viene resa disponibile al modello After mapping del risolutore di pipeline.

** `info` **  
Un oggetto contenente le informazioni sulla richiesta GraphQL. Per la struttura di questo campo, consulta [Info](#aws-appsync-resolver-context-reference-info).

### Identità
<a name="aws-appsync-resolver-context-reference-identity"></a>

La sezione `identity` contiene le informazioni sul chiamante. La forma di questa sezione dipende dal tipo di autorizzazione dell'API. AWS AppSync 

Per ulteriori informazioni sulle opzioni di AWS AppSync sicurezza, consulta [Autorizzazione e autenticazione](security-authz.md#aws-appsync-security).

** Autorizzazione `API_KEY`**  
Il `identity` campo non è compilato.

**Autorizzazione `AWS_LAMBDA`**  
`identity`Contiene la `resolverContext` chiave, contenente lo stesso `resolverContext` contenuto restituito dalla funzione Lambda che autorizza la richiesta.

** Autorizzazione `AWS_IAM`**  
`identity`Ha la seguente forma:  

```
{
    "accountId" : "string",
    "cognitoIdentityPoolId" : "string",
    "cognitoIdentityId" : "string",
    "sourceIp" : ["string"],
    "username" : "string", // IAM user principal
    "userArn" : "string",
    "cognitoIdentityAuthType" : "string", // authenticated/unauthenticated based on the identity type
    "cognitoIdentityAuthProvider" : "string" // the auth provider that was used to obtain the credentials
}
```

** Autorizzazione `AMAZON_COGNITO_USER_POOLS`**  
`identity`Ha la forma seguente:  

```
{
    "sub" : "uuid",
    "issuer" : "string",
    "username" : "string"
    "claims" : { ... },
    "sourceIp" : ["x.x.x.x"],
    "defaultAuthStrategy" : "string"
}
```

Ogni campo è definito nel modo seguente:

** `accountId` **  
L'ID dell' AWS account del chiamante.

** `claims` **  
Le attestazioni dell'utente.

** `cognitoIdentityAuthType` **  
Autenticato o non autenticato in base al tipo di identità.

** `cognitoIdentityAuthProvider` **  
Un elenco separato da virgole di informazioni sul provider di identità esterno utilizzato per ottenere le credenziali utilizzate per firmare la richiesta.

** `cognitoIdentityId` **  
L'ID identificativo Amazon Cognito del chiamante.

** `cognitoIdentityPoolId` **  
L'ID del pool di identità di Amazon Cognito associato al chiamante.

** `defaultAuthStrategy` **  
La strategia di autorizzazione predefinita per questo chiamante (`ALLOW` o `DENY`).

** `issuer` **  
L'emittente del token.

** `sourceIp` **  
L'indirizzo IP di origine del chiamante che riceve. AWS AppSync Se la richiesta non include l'`x-forwarded-for`intestazione, il valore IP di origine contiene solo un singolo indirizzo IP della connessione TCP. Se la richiesta include un'intestazione `x-forwarded-for`, l'IP di origine sarà un elenco di indirizzi IP dell'intestazione `x-forwarded-for` oltre all'indirizzo IP proveniente dalla connessione TCP.

** `sub` **  
l'UUID dell'utente autenticato.

** `user` **  
L'utente IAM.

** `userArn` **  
L'Amazon Resource Name (ARN) dell'utente IAM.

** `username` **  
Il nome dell'utente autenticato. In caso di autorizzazione `AMAZON_COGNITO_USER_POOLS`, il valore del *nome utente* è il valore dell'attributo *cognito:username*. In caso di `AWS_IAM` autorizzazione, il valore del *nome utente* è il valore del principale AWS utente. Se utilizzi l'autorizzazione IAM con credenziali fornite dai pool di identità di Amazon Cognito, ti consigliamo di utilizzare. `cognitoIdentityId`

### Intestazioni delle richieste di accesso
<a name="aws-appsync-resolver-context-reference-util"></a>

AWS AppSync supporta il passaggio di intestazioni personalizzate dai client e l'accesso ad esse nei resolver GraphQL utilizzando. `$context.request.headers` È quindi possibile utilizzare i valori dell'intestazione per azioni come l'inserimento di dati in una fonte di dati o i controlli di autorizzazione. È possibile utilizzare intestazioni di richiesta singole o multiple utilizzando `$curl` una chiave API dalla riga di comando, come illustrato negli esempi seguenti:

**Esempio di intestazione singola** 

Supponi di impostare un'intestazione `custom` con il valore `nadia` come segue:

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Potrai quindi accedervi con `$context.request.headers.custom`. Ad esempio, potrebbe trovarsi nel seguente VTL per DynamoDB:

```
"custom": $util.dynamodb.toDynamoDBJson($context.request.headers.custom)
```

**Esempio di intestazione multipla** 

Puoi anche passare intestazioni multiple in una singola richiesta e accedervi nel modello di mappatura del resolver. Ad esempio, se l'`custom`intestazione è impostata con due valori:

```
curl -XPOST -H "Content-Type:application/graphql" -H "custom:bailey" -H "custom:nadia" -H "x-api-key:<API-KEY-VALUE>" -d '{"query":"mutation { createEvent(name: \"demo\", when: \"Next Friday!\", where: \"Here!\") {id name when where description}}"}' https://<ENDPOINT>/graphql
```

Potrai quindi accedervi come matrice, ad esempio `$context.request.headers.custom[1]`.

**Nota**  
AWS AppSync non espone l'intestazione del cookie in. `$context.request.headers`

### Accedi al nome di dominio personalizzato della richiesta
<a name="aws-access-requested-custom-domain-names"></a>

AWS AppSync supporta la configurazione di un dominio personalizzato che puoi utilizzare per accedere ai tuoi endpoint GraphQL e in tempo reale per il tuo. APIs Quando si effettua una richiesta con un nome di dominio personalizzato, è possibile ottenere il nome di dominio utilizzando. `$context.request.domainName`

Quando si utilizza il nome di dominio endpoint GraphQL predefinito, il valore è. `null`

### Informazioni
<a name="aws-appsync-resolver-context-reference-info"></a>

La sezione `info` contiene informazioni sulla richiesta GraphQL. Questa sezione ha il seguente formato:

```
{
    "fieldName": "string",
    "parentTypeName": "string",
    "variables": { ... },
    "selectionSetList": ["string"],
    "selectionSetGraphQL": "string"
}
```

Ogni campo è definito nel modo seguente:

** `fieldName` **  
Il nome del campo attualmente in corso di risoluzione.

** `parentTypeName` **  
Il nome del tipo padre per il campo attualmente in corso di risoluzione.

** `variables` **  
Una mappa contenente tutte le variabili che vengono passate nella richiesta GraphQL.

** `selectionSetList` **  
Rappresentazione elenco dei campi nel set di selezione GraphQL. I campi con alias sono referenziati solo dal nome dell'alias, non dal nome del campo. L'esempio seguente mostra questa indicazione in dettaglio.

** `selectionSetGraphQL` **  
Rappresentazione stringa del set di selezione, formattata come SDL (Schema Definition Language) GraphQL. Sebbene i frammenti non vengano uniti nel set di selezione, i frammenti in linea vengono conservati, come illustrato nell'esempio seguente.

**Nota**  
Quando si utilizza `$utils.toJson()` on`context.info`, i valori che `selectionSetGraphQL` e `selectionSetList` restituiscono non vengono serializzati per impostazione predefinita.

Ad esempio, se stai risolvendo il campo `getPost` della query seguente:

```
query {
  getPost(id: $postId) {
    postId
    title
    secondTitle: title
    content
    author(id: $authorId) {
      authorId
      name
    }
    secondAuthor(id: "789") {
      authorId
    }
    ... on Post {
      inlineFrag: comments: {
        id
      }
    }
    ... postFrag
  }
}

fragment postFrag on Post {
  postFrag: comments: {
    id
  }
}
```

La variabile `$context.info` completa disponibile durante l'elaborazione di un modello di mappatura potrebbe essere:

```
{
  "fieldName": "getPost",
  "parentTypeName": "Query",
  "variables": {
    "postId": "123",
    "authorId": "456"
  },
  "selectionSetList": [
    "postId",
    "title",
    "secondTitle"
    "content",
    "author",
    "author/authorId",
    "author/name",
    "secondAuthor",
    "secondAuthor/authorId",
    "inlineFragComments",
    "inlineFragComments/id",
    "postFragComments",
    "postFragComments/id"
  ],
  "selectionSetGraphQL": "{\n  getPost(id: $postId) {\n    postId\n    title\n    secondTitle: title\n    content\n    author(id: $authorId) {\n      authorId\n      name\n    }\n    secondAuthor(id: \"789\") {\n      authorId\n    }\n    ... on Post {\n      inlineFrag: comments {\n        id\n      }\n    }\n    ... postFrag\n  }\n}"
}
```

`selectionSetList`espone solo i campi che appartengono al tipo corrente. Se il tipo corrente è un'interfaccia o un'unione, vengono esposti solo i campi selezionati che appartengono all'interfaccia. Ad esempio, dato lo schema seguente:

```
type Query {
    node(id: ID!): Node
}

interface Node {
    id: ID
}

type Post implements Node {
    id: ID
    title: String
    author: String
}

type Blog implements Node {
    id: ID
    title: String
    category: String
}
```

E la seguente domanda:

```
query {
    node(id: "post1") {
        id
        ... on Post {
            title
        }

        ... on Blog {
            title
        }
    }
}
```

Quando si chiama `$ctx.info.selectionSetList` alla risoluzione del `Query.node` campo, `id` viene esposto solo:

```
"selectionSetList": [
    "id"
]
```

## Neutralizzazione degli input
<a name="sanitizing-inputs"></a>

Le applicazioni devono neutralizzare gli input non attendibili per impedire a qualsiasi parte esterna di utilizzare un'applicazione al di fuori dell'uso previsto. Poiché `$context` contiene gli input degli utenti in proprietà come`$context.arguments`,,, e`$context.request.headers`,,`$context.identity`,`$context.result`,`$context.info.variables`, è necessario prestare attenzione a ripulirne i valori nei modelli di mappatura.

Poiché i modelli di mapping sono rappresentati in JSON, la neutralizzazione degli input assume la forma di caratteri riservati JSON di escape delle stringhe che rappresentano gli input dell'utente. È consigliabile utilizzare l'utilità `$util.toJson()` per applicare i caratteri riservati JSON di escape di valori di stringa sensibili quando vengono inseriti in un modello di mapping.

Ad esempio, nel seguente modello di mappatura delle richieste Lambda, poiché abbiamo avuto accesso a una stringa di input del cliente non sicura (`$context.arguments.id`), l'abbiamo inserita `$util.toJson()` per evitare che i caratteri JSON senza escape violassero il modello JSON.

```
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": $util.toJson($context.arguments.id)
    }
}
```

A differenza del modello di mappatura riportato di seguito, in cui inseriamo direttamente senza sanificazione. `$context.arguments.id` Questo non funziona per le stringhe che contengono virgolette senza scampo o altri caratteri riservati JSON e può lasciare il modello esposto a errori.

```
## DO NOT DO THIS
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "postId": "$context.arguments.id" ## Unsafe! Do not insert $context string values without escaping JSON characters.
    }
}
```

# AWS AppSync riferimento all'utilità del modello di mappatura del resolver
<a name="resolver-util-reference"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync definisce un set di utilità che è possibile utilizzare all'interno di un resolver GraphQL per semplificare le interazioni con le fonti di dati. Alcune di queste utilità sono destinate all'uso generale con qualsiasi fonte di dati, ad esempio la generazione o i timestamp. IDs Altre sono specifiche per un tipo di origine dati. Sono disponibili le seguenti utilità:
+  [Utility helper in \$1util](https://docs.aws.amazon.com/appsync/latest/devguide/utility-helpers-in-util.html) - La variabile \$1util contiene metodi di utilità generali per facilitare l'utilizzo dei dati. Se non diversamente specificato, tutte le utilità usano il set di caratteri UTF-8.
+ [ AppSync direttive: AppSync espone le](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-directives.html) direttive per facilitare la produttività degli sviluppatori durante la scrittura in VTL.
+  [Time helpers in \$1util.time - La variabile \$1util.time](https://docs.aws.amazon.com/appsync/latest/devguide/time-helpers-in-util-time.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)
+ [List helpers in \$1util.list - \$1util.list](https://docs.aws.amazon.com/appsync/latest/devguide/list-helpers-in-util-list.html) contiene metodi per facilitare le operazioni List più comuni, come la rimozione o il mantenimento di elementi da un elenco per filtrare i casi d'uso.
+  [Map helpers in \$1util.map - \$1util.map](https://docs.aws.amazon.com/appsync/latest/devguide/utility-helpers-in-map.html) contiene metodi per facilitare le operazioni più comuni sulle mappe, come la rimozione o il mantenimento di elementi da una mappa per filtrare i casi d'uso.
+  [Helper DynamoDB in \$1util.dynamodb - \$1util.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.html) e la formattazione automatiche dei tipi. 
+  [Gli helper di Amazon RDS in \$1util.rds - \$1util.rds](https://docs.aws.amazon.com/appsync/latest/devguide/rds-helpers-in-util-rds.html) contengono metodi di supporto che formattano le operazioni RDS eliminando i dati estranei negli output dei risultati.
+  [Helper HTTP in \$1util.http - L'utilità \$1util.http fornisce metodi di supporto che puoi usare per gestire i parametri di richiesta HTTP](https://docs.aws.amazon.com/appsync/latest/devguide/http-helpers-in-utils-http.html) e aggiungere intestazioni di risposta.
+  [Helper XML in \$1util.xml - \$1util.xml](https://docs.aws.amazon.com/appsync/latest/devguide/xml-helpers-in-utils-xml.html) contiene metodi di supporto che possono semplificare la traduzione delle risposte XML in JSON o in un dizionario.
+  [Aiutanti di trasformazione in \$1util.transform - \$1util.transform](https://docs.aws.amazon.com/appsync/latest/devguide/transformation-helpers-in-utils-transform.html) contiene metodi di supporto che semplificano l'esecuzione di operazioni complesse su fonti di dati, come le operazioni di filtro DynamoDB.
+  [Aiutanti matematici in \$1util.math - \$1util.math contiene metodi per facilitare le operazioni matematiche più](https://docs.aws.amazon.com/appsync/latest/devguide/math-helpers-in-util-math.html) comuni.
+  [String helpers in \$1util.str - \$1util.str contiene metodi per facilitare le operazioni più comuni sulle](https://docs.aws.amazon.com/appsync/latest/devguide/str-helpers-in-util-str.html) stringhe.
+  [Extensions - \$1extensions](https://docs.aws.amazon.com/appsync/latest/devguide/extensions.html) contiene una serie di metodi per eseguire azioni aggiuntive all'interno dei resolver.

# Utility helper in \$1util
<a name="utility-helpers-in-util"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

La `$util` variabile 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.

## Utilità di analisi JSON
<a name="utility-helpers-in-json-parsing"></a>

### Elenco degli strumenti di analisi JSON
<a name="utility-helpers-in-json-parsing-list"></a>

** **`$util.parseJson(String) : Object`** **  
Da una stringa JSON restituisce una rappresentazione oggetto del risultato.

** **`$util.toJson(Object) : String`** **  
Da un oggetto restituisce una rappresentazione JSON "a stringhe" di tale oggetto.

## Utilità di codifica
<a name="utility-helpers-in-encoding"></a>

### Elenco degli strumenti di codifica
<a name="utility-helpers-in-encoding-list"></a>

** **`$util.urlEncode(String) : String`** **  
Restituisce la stringa di input come stringa codificata `application/x-www-form-urlencoded`.

** **`$util.urlDecode(String) : String`** **  
Decodifica una stringa codificata `application/x-www-form-urlencoded` nella relativa forma non codificata.

** **`$util.base64Encode( byte[] ) : String`** **  
Codifica l'input in una stringa con codifica base64.

** **`$util.base64Decode(String) : byte[]`** **  
Decodifica i dati da una stringa con codifica base64.

## Utilità per la generazione di ID
<a name="utility-helpers-in-id-gen"></a>

### Elenco di utilità per la generazione di ID
<a name="utility-helpers-in-id-gen-list"></a>

** **`$util.autoId() : String`** **  
Restituisce un valore UUID generato casualmente a 128 bit.

****`$util.autoUlid() : String`****  
Restituisce un ULID (Universally Unique Lexicographically Sortable Identifier) generato casualmente a 128 bit.

****`$util.autoKsuid() : String`****  
Restituisce un KSUID (K-Sortable Unique Identifier) base62 generato casualmente a 128 bit codificato come String con una lunghezza di 27.

## Utili di errore
<a name="utility-helpers-in-error"></a>

### Elenco delle utilità di errore
<a name="utility-helpers-in-error-list"></a>

** `$util.error(String)` **  
Genera un errore personalizzato. Utilizzalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata.

** `$util.error(String, String)` **  
Genera un errore personalizzato. Usalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata. Puoi anche specificare un. `errorType`

** `$util.error(String, String, Object)` **  
Genera un errore personalizzato. Utilizzalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata. Puoi anche specificare un campo `errorType` e un. `data` 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.

** `$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 della query. 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 query.

** `$util.appendError(String)` **  
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. A differenza di `$util.error(String)`, la valutazione del modello non viene interrotta, in modo che i dati possano essere restituiti al chiamante.

** `$util.appendError(String, String)` **  
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 possibile specificare un campo `errorType`. A differenza di `$util.error(String, String)`, la valutazione del modello non viene interrotta, in modo che i dati possano essere restituiti al chiamante.

** `$util.appendError(String, String, 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 possibile specificare un campo `errorType` e un campo `data`. A differenza di `$util.error(String, String, 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 delle query.

** `$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 della query. 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 query.

## Utilità per la convalida delle condizioni
<a name="utility-helpers-in-condition"></a>

### Elenco degli strumenti di convalida delle condizioni
<a name="utility-helpers-in-condition-list"></a>

** `$util.validate(Boolean, String) : void` **  
Se la condizione è falsa, lancia un messaggio CustomTemplateException con il messaggio specificato.

** `$util.validate(Boolean, String, String) : void` **  
Se la condizione è falsa, genera un messaggio CustomTemplateException con il messaggio e il tipo di errore specificati.

** `$util.validate(Boolean, String, String, Object) : void` **  
Se la condizione è falsa, genera un messaggio CustomTemplateException con il messaggio e il tipo di errore specificati, oltre ai dati da restituire nella risposta.

## Utilità comportamentali nulle
<a name="utility-helpers-in-null-behavior"></a>

### Elenco di utilità con comportamento nullo
<a name="utility-helpers-in-null-behavior-list"></a>

** `$util.isNull(Object) : Boolean` **  
Restituisce true se l'oggetto fornito è null.

** `$util.isNullOrEmpty(String) : Boolean` **  
Restituisce true se i dati forniti sono null o una stringa vuota. In caso contrario, restituisce false.

** `$util.isNullOrBlank(String) : Boolean` **  
Restituisce true se i dati forniti sono null o una stringa vuota. In caso contrario, restituisce false.

** `$util.defaultIfNull(Object, Object) : Object` **  
Restituisce il primo oggetto se non è null. In caso contrario, restituisce il secondo oggetto come "oggetto predefinito".

** `$util.defaultIfNullOrEmpty(String, String) : String` **  
Restituisce la prima stringa se non è null o vuota. In caso contrario, restituisce la seconda stringa come "stringa predefinita".

** `$util.defaultIfNullOrBlank(String, String) : String` **  
Restituisce la prima stringa se non è null o vuota. In caso contrario, restituisce la seconda stringa come "stringa predefinita".

## Utilità per la corrispondenza dei modelli
<a name="utility-helpers-in-pattern-matching"></a>

### Elenco degli strumenti per la corrispondenza dei tipi e dei modelli
<a name="utility-helpers-in-type-pattern-matching-list"></a>

** `$util.typeOf(Object) : String` **  
Restituisce una stringa che descrive il tipo di oggetto. Le identificazioni di tipi supportate sono: "Null", "Number", "String", "Map", "List", "Boolean". Se un tipo non può essere identificato, il tipo restituito è "Object".

** `$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() : String` **  
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».

## Utilità di convalida degli oggetti
<a name="utility-helpers-in-object-validation"></a>

### Elenco degli strumenti di convalida degli oggetti
<a name="utility-helpers-in-object-validation-list"></a>

** `$util.isString(Object) : Boolean` **  
Restituisce true se l'oggetto è una stringa.

** `$util.isNumber(Object) : Boolean` **  
Restituisce true se l'oggetto è un numero.

** `$util.isBoolean(Object) : Boolean` **  
Restituisce true se l'oggetto è un valore booleano.

** `$util.isList(Object) : Boolean` **  
Restituisce true se l'oggetto è un elenco.

** `$util.isMap(Object) : Boolean` **  
Restituisce true se l'oggetto è una mappa.

## CloudWatch utilità di registrazione
<a name="utility-helpers-in-logging"></a>

### CloudWatch lista di utilità di registrazione
<a name="utility-helpers-in-cloudwatch-logs"></a>

**`$util.log.info(Object) : Void`**  
Registra la rappresentazione String dell'oggetto fornito nel flusso di registro richiesto quando la registrazione a livello di richiesta e di campo è abilitata con CloudWatch log level o su un'API. `ALL` `INFO` `DEBUG`

**`$util.log.info(String, Object...) : Void`**  
Registra la rappresentazione String degli oggetti forniti nel flusso di registro richiesto quando la registrazione a livello di richiesta e di campo è CloudWatch abilitata con il livello di log su un'API. `ALL` Questa utilità sostituirà tutte le variabili indicate da «\$1\$1» nella prima stringa di formato di input con la rappresentazione String degli oggetti forniti nell'ordine.

**`$util.log.debug(Object) : Void`**  
Registra la rappresentazione String dell'oggetto fornito nel flusso di registro richiesto quando la registrazione a livello di richiesta e di campo è abilitata con il livello CloudWatch di log o su un'API. `ALL` `DEBUG`

**`$util.log.debug(String, Object...) : Void`**  
Registra la rappresentazione String degli oggetti forniti nel flusso di registro richiesto quando la registrazione a livello di campo è abilitata con livello di registro o livello CloudWatch di registro su un'API. `DEBUG` `ALL` Questa utilità sostituirà tutte le variabili indicate da «\$1\$1» nella prima stringa di formato di input con la rappresentazione String degli oggetti forniti nell'ordine.

**`$util.log.error(Object) : Void`**  
Registra la rappresentazione in formato String dell'oggetto fornito nel flusso di log richiesto quando la CloudWatch registrazione a livello di campo è abilitata con **qualsiasi** livello di registro (`ALL`, `INFO``DEBUG`, ecc.) su un'API.

**`$util.log.error(String, Object...) : Void`**  
Registra la rappresentazione String degli oggetti forniti nel flusso di registro richiesto quando la registrazione a livello di campo è abilitata con livello di CloudWatch registro o livello di registro su un'API. `ERROR` `ALL` Questa utilità sostituirà tutte le variabili indicate da «\$1\$1» nella prima stringa di formato di input con la rappresentazione String degli oggetti forniti nell'ordine.

## Restituisce il valore di comportamento (utils)
<a name="utility-helpers-in-return-behavior"></a>

### Elenco delle utilità di comportamento del valore restituito
<a name="utility-helpers-in-behavior-list"></a>

****`$util.qr()`** e `$util.quiet()` **  
Esegue un'istruzione VTL mentre sopprime il valore restituito. Ciò è utile per eseguire metodi senza utilizzare segnaposti temporanei, ad esempio aggiungere elementi a una mappa. Esempio:  

```
#set ($myMap = {})
#set($discard = $myMap.put("id", "first value"))
```
Diventa:  

```
#set ($myMap = {})
$util.qr($myMap.put("id", "first value"))
```  
** `$util.escapeJavaScript(String) : String` **  
Restituisce la stringa di input come stringa di JavaScript escape.  
** `$util.urlEncode(String) : String` **  
Restituisce la stringa di input come stringa codificata `application/x-www-form-urlencoded`.  
** `$util.urlDecode(String) : String` **  
Decodifica una stringa codificata `application/x-www-form-urlencoded` nella relativa forma non codificata.  
** `$util.base64Encode( byte[] ) : String` **  
Codifica l'input in una stringa con codifica base64.  
** `$util.base64Decode(String) : byte[]` **  
Decodifica i dati da una stringa con codifica base64.  
** `$util.parseJson(String) : Object` **  
Da una stringa JSON restituisce una rappresentazione oggetto del risultato.  
** `$util.toJson(Object) : String` **  
Da un oggetto restituisce una rappresentazione JSON "a stringhe" di tale oggetto.  
** `$util.autoId() : String` **  
Restituisce un valore UUID generato casualmente a 128 bit.  
****`$util.autoUlid() : String`****  
Restituisce un ULID (Universally Unique Lexicographically Sortable Identifier) generato casualmente a 128 bit.  
****`$util.autoKsuid() : String`****  
Restituisce un KSUID (K-Sortable Unique Identifier) base62 generato casualmente a 128 bit codificato come String con una lunghezza di 27.  
** `$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.  
** `$util.error(String)` **  
Genera un errore personalizzato. Utilizzalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata.  
** `$util.error(String, String)` **  
Genera un errore personalizzato. Usalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata. Puoi anche specificare un. `errorType`  
** `$util.error(String, String, Object)` **  
Genera un errore personalizzato. Utilizzalo nei modelli di mappatura delle richieste o delle risposte per rilevare un errore nella richiesta o nel risultato della chiamata. Puoi anche specificare un campo `errorType` e un. `data` Il valore di `data` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. **Nota**: `data` verrà filtrato in base al set di selezioni della query.  
** `$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 possibile specificare un campo `errorType`, un campo `data` e un campo `errorInfo`. Il valore di `data` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. **Nota**: `data` verrà filtrato in base al set di selezioni della query. Il valore di `errorInfo` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. **Nota**: `errorInfo` **NON** verrà filtrato in base al set di selezioni della query.  
** `$util.appendError(String)` **  
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. A differenza di `$util.error(String)`, la valutazione del modello non viene interrotta, in modo che i dati possano essere restituiti al chiamante.  
** `$util.appendError(String, String)` **  
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 possibile specificare un campo `errorType`. A differenza di `$util.error(String, String)`, la valutazione del modello non viene interrotta, in modo che i dati possano essere restituiti al chiamante.  
** `$util.appendError(String, String, 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 possibile specificare un campo `errorType` e un campo `data`. A differenza di `$util.error(String, String, 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. **Nota**: `data` verrà filtrato in base al set di selezioni della query.  
** `$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 possibile specificare un campo `errorType`, un campo `data` e un campo `errorInfo`. 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. **Nota**: `data` verrà filtrato in base al set di selezioni della query. Il valore di `errorInfo` verrà aggiunto al blocco `error` corrispondente all'interno di `errors` nella risposta di GraphQL. **Nota**: `errorInfo` **NON** verrà filtrato in base al set di selezioni della query.  
** `$util.validate(Boolean, String) : void` **  
Se la condizione è falsa, lancia un messaggio CustomTemplateException con il messaggio specificato.  
** `$util.validate(Boolean, String, String) : void` **  
Se la condizione è falsa, genera un messaggio CustomTemplateException con il messaggio e il tipo di errore specificati.  
** `$util.validate(Boolean, String, String, Object) : void` **  
Se la condizione è falsa, genera un messaggio CustomTemplateException con il messaggio e il tipo di errore specificati, oltre ai dati da restituire nella risposta.  
** `$util.isNull(Object) : Boolean` **  
Restituisce true se l'oggetto fornito è null.  
** `$util.isNullOrEmpty(String) : Boolean` **  
Restituisce true se i dati forniti sono null o una stringa vuota. In caso contrario, restituisce false.  
** `$util.isNullOrBlank(String) : Boolean` **  
Restituisce true se i dati forniti sono null o una stringa vuota. In caso contrario, restituisce false.  
** `$util.defaultIfNull(Object, Object) : Object` **  
Restituisce il primo oggetto se non è null. In caso contrario, restituisce il secondo oggetto come "oggetto predefinito".  
** `$util.defaultIfNullOrEmpty(String, String) : String` **  
Restituisce la prima stringa se non è null o vuota. In caso contrario, restituisce la seconda stringa come "stringa predefinita".  
** `$util.defaultIfNullOrBlank(String, String) : String` **  
Restituisce la prima stringa se non è null o vuota. In caso contrario, restituisce la seconda stringa come "stringa predefinita".  
** `$util.isString(Object) : Boolean` **  
Restituisce true se l'oggetto è una stringa.  
** `$util.isNumber(Object) : Boolean` **  
Restituisce true se l'oggetto è un numero.  
** `$util.isBoolean(Object) : Boolean` **  
Restituisce true se l'oggetto è un valore booleano.  
** `$util.isList(Object) : Boolean` **  
Restituisce true se l'oggetto è un elenco.  
** `$util.isMap(Object) : Boolean` **  
Restituisce true se l'oggetto è una mappa.  
** `$util.typeOf(Object) : String` **  
Restituisce una stringa che descrive il tipo di oggetto. Le identificazioni di tipi supportate sono: "Null", "Number", "String", "Map", "List", "Boolean". Se un tipo non può essere identificato, il tipo restituito è "Object".  
** `$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() : String` **  
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».  
****`$util.log.info(Object) : Void`****  
Registra la rappresentazione in formato String dell'oggetto fornito nel flusso di registro richiesto quando la registrazione a livello di richiesta e di campo è abilitata con il livello di log su CloudWatch un'API. `ALL`  
****`$util.log.info(String, Object...) : Void`****  
Registra la rappresentazione String degli oggetti forniti nel flusso di registro richiesto quando la registrazione a livello di richiesta e di campo è CloudWatch abilitata con il livello di log su un'API. `ALL` Questa utilità sostituirà tutte le variabili indicate da «\$1\$1» nella prima stringa di formato di input con la rappresentazione String degli oggetti forniti nell'ordine.  
****`$util.log.error(Object) : Void`****  
Registra la rappresentazione String dell'oggetto fornito nel flusso di log richiesto quando la CloudWatch registrazione a livello di campo è abilitata con livello di registro `ERROR` o livello di registro su un'API. `ALL`  
****`$util.log.error(String, Object...) : Void`****  
Registra la rappresentazione String degli oggetti forniti nel flusso di registro richiesto quando la registrazione a livello di campo è abilitata con livello di CloudWatch registro o livello di registro su un'API. `ERROR` `ALL` Questa utilità sostituirà tutte le variabili indicate da «\$1\$1» nella prima stringa di formato di input con la rappresentazione String degli oggetti forniti nell'ordine.

** `$util.escapeJavaScript(String) : String` **  
Restituisce la stringa di input come stringa JavaScript di escape.

## Autorizzazione Resolver
<a name="utility-helpers-in-resolver-auth"></a>

### Elenco di autorizzazioni del resolver
<a name="utility-helpers-in-resolver-auth-list"></a>

** `$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.

# AWS AppSync direttive
<a name="aws-appsync-directives"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

AWS AppSync espone direttive per facilitare la produttività degli sviluppatori durante la scrittura in VTL.

## Utilità direttive
<a name="utility-helpers-in-directives"></a>

****`#return(Object)`****  
`#return(Object)`Consente di tornare prematuramente da qualsiasi modello di mappatura. `#return(Object)`è analoga alla parola chiave *return* nei linguaggi di programmazione, in quanto restituirà dal blocco logico con ambito più vicino. L'utilizzo `#return(Object)` all'interno di un modello di mappatura del resolver verrà restituito dal resolver. Inoltre, l'utilizzo `#return(Object)` di un modello di mappatura delle funzioni ritornerà dalla funzione e proseguirà l'esecuzione verso la funzione successiva nella pipeline o il modello di mappatura delle risposte del resolver.

****`#return`****  
La `#return` direttiva mostra gli stessi comportamenti di, ma verrà invece restituita`#return(Object)`. `null`

# Aiutanti temporali in \$1util.time
<a name="time-helpers-in-util-time"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

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. Di seguito forniamo alcuni esempi, oltre a un elenco di metodi e descrizioni disponibili.

## Utilità temporali
<a name="utility-helpers-in-time"></a>

### Elenco delle utilità temporali
<a name="utility-helpers-in-time-list"></a>

** `$util.time.nowISO8601() : String` **  
[Restituisce una rappresentazione String di UTC in ISO8601 formato.](https://en.wikipedia.org/wiki/ISO_8601)

** `$util.time.nowEpochSeconds() : long` **  
Restituisce il numero di secondi dall'epoca (Unix epoch) 1970-01-01T00:00:00Z a ora.

** `$util.time.nowEpochMilliSeconds() : long` **  
Restituisce il numero di millisecondi dall'epoca (Unix epoch) 1970-01-01T00:00:00Z a ora.

** `$util.time.nowFormatted(String) : String` **  
Restituisce una stringa del timestamp corrente in UTC utilizzando il formato specificato da un tipo di input stringa.

** `$util.time.nowFormatted(String, 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) : Long` **  
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) : Long` **  
Analizza un timestamp passato come String insieme a un formato e un fuso orario, quindi restituisce il timestamp in millisecondi dall'epoca.

** `$util.time.parseISO8601ToEpochMilliSeconds(String) : Long` **  
Analizza un ISO8601 timestamp passato come String, quindi restituisce il timestamp in millisecondi trascorsi da epoch.

** `$util.time.epochMilliSecondsToSeconds(long) : 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) : String` **  
Converte il timestamp di un'epoca in millisecondi in un timestamp. ISO8601

** `$util.time.epochMilliSecondsToFormatted(long, String) : 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) : String` **  
Converte il timestamp di un'epoca in millisecondi, passato come long, in un timestamp formattato secondo il formato fornito nel fuso orario fornito.

## Esempi di funzioni autonome
<a name="standalone-function-examples"></a>

```
$util.time.nowISO8601()                                            : 2018-02-06T19:01:35.749Z
$util.time.nowEpochSeconds()                                       : 1517943695
$util.time.nowEpochMilliSeconds()                                  : 1517943695750
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ")                    : 2018-02-06 19:01:35+0000
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ", "+08:00")          : 2018-02-07 03:01:35+0800
$util.time.nowFormatted("yyyy-MM-dd HH:mm:ssZ", "Australia/Perth") : 2018-02-07 03:01:35+0800
```

## Esempi di conversione
<a name="conversion-examples"></a>

```
#set( $nowEpochMillis = 1517943695758 )
$util.time.epochMilliSecondsToSeconds($nowEpochMillis)                                     : 1517943695
$util.time.epochMilliSecondsToISO8601($nowEpochMillis)                                     : 2018-02-06T19:01:35.758Z
$util.time.epochMilliSecondsToFormatted($nowEpochMillis, "yyyy-MM-dd HH:mm:ssZ")           : 2018-02-06 19:01:35+0000
$util.time.epochMilliSecondsToFormatted($nowEpochMillis, "yyyy-MM-dd HH:mm:ssZ", "+08:00") : 2018-02-07 03:01:35+0800
```

## Esempi di analisi
<a name="parsing-examples"></a>

```
$util.time.parseISO8601ToEpochMilliSeconds("2018-02-01T17:21:05.180+08:00")                          : 1517476865180
$util.time.parseFormattedToEpochMilliSeconds("2018-02-02 01:19:22+0800", "yyyy-MM-dd HH:mm:ssZ")     : 1517505562000
$util.time.parseFormattedToEpochMilliSeconds("2018-02-02 01:19:22", "yyyy-MM-dd HH:mm:ss", "+08:00") : 1517505562000
```

## Utilizzo con scalari AWS AppSync definiti
<a name="usage-with-aws-scalars"></a>

I seguenti formati sono compatibili con `AWSDate`, `AWSDateTime` e `AWSTime`.

```
$util.time.nowFormatted("yyyy-MM-dd[XXX]", "-07:00:30")               : 2018-07-11-07:00
$util.time.nowFormatted("yyyy-MM-dd'T'HH:mm:ss[XXXXX]", "-07:00:30")  : 2018-07-11T15:14:15-07:00:30
```

# Elenca gli aiutanti in \$1util.list
<a name="list-helpers-in-util-list"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.list`contiene metodi per facilitare le operazioni più comuni di List, come la rimozione o il mantenimento di elementi da un elenco per filtrare i casi d'uso.

## Elenca gli strumenti
<a name="utility-helpers-in-list-utils"></a>

** `$util.list.copyAndRetainAll(List, List) : List` **  
Crea una copia superficiale dell'elenco fornito nel primo argomento conservando solo gli elementi specificati nel secondo argomento, se presenti. Tutti gli altri elementi verranno rimossi dalla copia.

** `$util.list.copyAndRemoveAll(List, List) : List` **  
Crea una copia superficiale dell'elenco fornito nel primo argomento rimuovendo tutti gli elementi in cui l'elemento è specificato nel secondo argomento, se presenti. Tutti gli altri elementi verranno mantenuti nella copia.

** `$util.list.sortList(List, Boolean, String) : List` **  
Ordina un elenco di oggetti, fornito nel primo argomento. Se il secondo argomento è vero, l'elenco viene ordinato in modo decrescente; se il secondo argomento è falso, l'elenco viene ordinato in modo crescente. Il terzo argomento è il nome della stringa della proprietà utilizzata per ordinare un elenco di oggetti personalizzati. Se si tratta di un elenco di sole stringhe, numeri interi, float o doppi, il terzo argomento può essere qualsiasi stringa casuale. Se tutti gli oggetti non appartengono alla stessa classe, viene restituito l'elenco originale. Sono supportati solo gli elenchi contenenti un massimo di 1000 oggetti. Di seguito è riportato un esempio di utilizzo di questa utilità:   

```
 INPUT:      $util.list.sortList([{"description":"youngest", "age":5},{"description":"middle", "age":45}, {"description":"oldest", "age":85}], false, "description")
 OUTPUT:     [{"description":"middle", "age":45}, {"description":"oldest", "age":85}, {"description":"youngest", "age":5}]
```

# Aiutanti di mappe in \$1util.map
<a name="utility-helpers-in-map"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.map`contiene metodi per facilitare le operazioni più comuni della mappa, come la rimozione o il mantenimento di elementi da una mappa per filtrare i casi d'uso.

## Utilità della mappa
<a name="utility-helpers-in-map-list"></a>

** `$util.map.copyAndRetainAllKeys(Map, List) : Map` **  
Crea una copia superficiale della prima mappa conservando solo le chiavi specificate nell'elenco, se presenti. Tutte le altre chiavi verranno rimosse dalla copia.

** `$util.map.copyAndRemoveAllKeys(Map, List) : Map` **  
Crea una copia superficiale della prima mappa rimuovendo tutte le voci in cui la chiave è specificata nell'elenco, se presenti. Tutte le altre chiavi verranno mantenute nella copia.

# Helper DynamoDB in \$1util.dynamodb
<a name="dynamodb-helpers-in-util-dynamodb"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$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. Questi metodi sono progettati per mappare automaticamente i tipi e gli elenchi primitivi nel formato di input DynamoDB corretto, che è uno dei formati. `Map` `{ "TYPE" : VALUE }`

Ad esempio, in precedenza, un modello di mappatura delle richieste per creare un nuovo elemento in DynamoDB avrebbe potuto avere il seguente aspetto:

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : { "S" : "$util.autoId()" }
    },
    "attributeValues" : {
         "title" : { "S" : $util.toJson($ctx.args.title) },
         "author" : { "S" : $util.toJson($ctx.args.author) },
         "version" : { "N", $util.toJson($ctx.args.version) }
    }
}
```

Per aggiungere campi all'oggetto sarebbe stato necessario aggiornare la query GraphQL nello schema, nonché il modello di mappatura della richiesta. Tuttavia, ora possiamo ristrutturare il nostro modello di mappatura delle richieste in modo che raccolga automaticamente i nuovi campi aggiunti nel nostro schema e li aggiunga a DynamoDB con i tipi corretti:

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },
    "attributeValues" : $util.dynamodb.toMapValuesJson($ctx.args)
}
```

Nell'esempio precedente, utilizziamo l'`$util.dynamodb.toDynamoDBJson(...)`helper per prendere automaticamente l'id generato e convertirlo nella rappresentazione DynamoDB di un attributo stringa. Quindi prendiamo tutti gli argomenti e li convertiamo nelle loro rappresentazioni DynamoDB e li inviamo nel campo `attributeValues` del modello.

Sono disponibili due versioni di ogni helper: una versione che restituisce un oggetto (ad esempio, `$util.dynamodb.toString(...)`) e una versione che restituisce l'oggetto come stringa JSON (ad esempio, `$util.dynamodb.toStringJson(...)`). Nell'esempio precedente abbiamo usato la versione che restituisce i dati come stringa JSON. Se vuoi modificare l'oggetto prima che venga usato nel modello, puoi scegliere di restituire invece un oggetto, come illustrato di seguito:

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "id" : $util.dynamodb.toDynamoDBJson($util.autoId())
    },

    #set( $myFoo = $util.dynamodb.toMapValues($ctx.args) )
    #set( $myFoo.version = $util.dynamodb.toNumber(1) )
    #set( $myFoo.timestamp = $util.dynamodb.toString($util.time.nowISO8601()))

    "attributeValues" : $util.toJson($myFoo)
}
```

Nell'esempio precedente, gli argomenti convertiti vengono restituiti come mappa invece di una stringa JSON, e vengono quindi aggiunti i campi `version` e `timestamp` prima di eseguirne l'output nel campo `attributeValues` del modello utilizzando `$util.toJson(...)`.

La versione JSON di ogni helper equivale al wrapping della versione non JSON in `$util.toJson(...)`. Ad esempio, le istruzioni seguenti sono identiche:

```
$util.toStringJson("Hello, World!")
$util.toJson($util.toString("Hello, World!"))
```

## A DynamoDB
<a name="utility-helpers-in-toDynamoDB"></a>

### Elenco di utilità ToDynamoDB
<a name="utility-helpers-in-toDynamoDB-list"></a>

** `$util.dynamodb.toDynamoDB(Object) : Map` **  
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" }
                       ]
                   }
               }
           }
```

****`$util.dynamodb.toDynamoDBJson(Object) : String`** **  
Uguale a`$util.dynamodb.toDynamoDB(Object) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## Utilità ToString
<a name="utility-helpers-in-toString"></a>

### Elenco di utilità ToString
<a name="utility-helpers-in-toString-list"></a>

****`$util.dynamodb.toString(String) : 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.toStringJson(String) : Map` **  
Uguale a`$util.dynamodb.toString(String) : String`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.toStringSet(List<String>) : Map` **  
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" ] }
```

** `$util.dynamodb.toStringSetJson(List<String>) : String` **  
Uguale a`$util.dynamodb.toStringSet(List<String>) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## ToNumber utils
<a name="utility-helpers-in-toNumber"></a>

### Elenco di utilità ToNumber
<a name="utility-helpers-in-toNumber-list"></a>

** `$util.dynamodb.toNumber(Number) : Map` **  
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.toNumberJson(Number) : String` **  
Uguale a`$util.dynamodb.toNumber(Number) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.toNumberSet(List<Number>) : Map` **  
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 ] }
```

** `$util.dynamodb.toNumberSetJson(List<Number>) : String` **  
Uguale a`$util.dynamodb.toNumberSet(List<Number>) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## ToBinary Utils
<a name="utility-helpers-in-toBinary"></a>

### Elenco di utilità ToBinary
<a name="utility-helpers-in-toBinary-list"></a>

** `$util.dynamodb.toBinary(String) : Map` **  
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.toBinaryJson(String) : String` **  
Uguale a`$util.dynamodb.toBinary(String) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.toBinarySet(List<String>) : Map` **  
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" ] }
```

** `$util.dynamodb.toBinarySetJson(List<String>) : String` **  
Uguale a`$util.dynamodb.toBinarySet(List<String>) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## ToBoolean utils
<a name="utility-helpers-in-toBoolean"></a>

### Elenco degli strumenti ToBoolean
<a name="utility-helpers-in-toBoolean-list"></a>

** `$util.dynamodb.toBoolean(Boolean) : Map` **  
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 }
```

** `$util.dynamodb.toBooleanJson(Boolean) : String` **  
Uguale a`$util.dynamodb.toBoolean(Boolean) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## ToNull utils
<a name="utility-helpers-in-toNull"></a>

### Elenco di utilità ToNull
<a name="utility-helpers-in-toNull-list"></a>

** `$util.dynamodb.toNull() : Map` **  
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 }
```

** `$util.dynamodb.toNullJson() : String` **  
Uguale a`$util.dynamodb.toNull() : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## Utilità ToList
<a name="utility-helpers-in-toList"></a>

### Elenco di utilità ToList
<a name="utility-helpers-in-toList-list"></a>

****`$util.dynamodb.toList(List) : Map`** **  
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" }
                       }
                   }
               ]
           }
```

** `$util.dynamodb.toListJson(List) : String` **  
Uguale a`$util.dynamodb.toList(List) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## Utilità ToMap
<a name="utility-helpers-in-toMap"></a>

### Elenco di utilità ToMap
<a name="utility-helpers-in-toMap-list"></a>

** `$util.dynamodb.toMap(Map) : 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.toMapJson(Map) : String` **  
Uguale a`$util.dynamodb.toMap(Map) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.toMapValues(Map) : 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) : Map` stesso. Ad esempio, le istruzioni seguenti sono identiche:  

```
$util.dynamodb.toMapValues($map)
$util.dynamodb.toMap($map).get("M")
```

** `$util.dynamodb.toMapValuesJson(Map) : String` **  
Uguale a`$util.dynamodb.toMapValues(Map) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

## Utilità S3Object
<a name="utility-helpers-in-S3Object"></a>

### Elenco delle utilità di S3Object
<a name="utility-helpers-in-S3Object-list"></a>

** `$util.dynamodb.toS3Object(String key, String bucket, String region) : Map` **  
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.toS3ObjectJson(String key, String bucket, String region) : String` **  
Uguale a`$util.dynamodb.toS3Object(String key, String bucket, String region) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map` **  
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.toS3ObjectJson(String key, String bucket, String region, String version) : String` **  
Uguale a`$util.dynamodb.toS3Object(String key, String bucket, String region, String version) : Map`, ma restituisce il valore dell'attributo DynamoDB come stringa codificata JSON.

** `$util.dynamodb.fromS3ObjectJson(String) : Map` **  
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" }
```

# Aiutanti Amazon RDS in \$1util.rds
<a name="rds-helpers-in-util-rds"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.rds`contiene metodi di supporto che formattano le operazioni di Amazon RDS eliminando i dati estranei negli output dei risultati.

## elenco di utilità \$1util.rds
<a name="rds-helpers-in-util-rds-list"></a>

****`$util.rds.toJsonString(String serializedSQLResult): String`****  
Restituisce un `String` trasformando il formato di risultato operativo grezzo di Amazon Relational Database Service (Amazon RDS) Data API con stringhe in una stringa più concisa. La stringa restituita è un elenco serializzato di record SQL del set di risultati. Ogni record è rappresentato da una raccolta di coppie chiave-valore. Le chiavi sono i nomi di colonna corrispondenti.  
Se l'istruzione corrispondente nell'input era una query SQL che causa una mutazione (ad esempio INSERT, UPDATE, DELETE), viene restituito un elenco vuoto. Ad esempio, la query `select * from Books limit 2` fornisce il risultato non elaborato dell'operazione Amazon RDS Data:  

```
{
    "sqlStatementResults": [
        {
            "numberOfRecordsUpdated": 0,
            "records": [
                [
                    {
                        "stringValue": "Mark Twain"
                    },
                    {
                        "stringValue": "Adventures of Huckleberry Finn"
                    },
                    {
                        "stringValue": "978-1948132817"
                    }
                ],
                [
                    {
                        "stringValue": "Jack London"
                    },
                    {
                        "stringValue": "The Call of the Wild"
                    },
                    {
                        "stringValue": "978-1948132275"
                    }
                  ]
            ],
            "columnMetadata": [
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "author",
                    "precision": 200,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "author"
                },
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "title",
                    "precision": 200,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "title"
                },
                {
                    "isSigned": false,
                    "isCurrency": false,
                    "label": "ISBN-13",
                    "precision": 15,
                    "typeName": "VARCHAR",
                    "scale": 0,
                    "isAutoIncrement": false,
                    "isCaseSensitive": false,
                    "schemaName": "",
                    "tableName": "Books",
                    "type": 12,
                    "nullable": 0,
                    "arrayBaseColumnType": 0,
                    "name": "ISBN-13"
                }
            ]
        }
    ]
}
```
Il `util.rds.toJsonString` è:  

```
[
  {
    "author": "Mark Twain",
    "title": "Adventures of Huckleberry Finn",
    "ISBN-13": "978-1948132817"
  },
  {
    "author": "Jack London",
    "title": "The Call of the Wild",
    "ISBN-13": "978-1948132275"
  },
]
```

****`$util.rds.toJsonObject(String serializedSQLResult): Object`****  
È lo stesso di`util.rds.toJsonString`, ma il risultato è un JSON`Object`.

# Aiutanti HTTP in \$1util.http
<a name="http-helpers-in-utils-http"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

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à \$1util.http
<a name="http-helpers-in-utils-http-list"></a>

** `$util.http.copyHeaders(Map) : Map` **  
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
È possibile utilizzare questa utilità per inoltrare le intestazioni delle richieste all'endpoint HTTP downstream.  

```
{
    ...
    "params": {
        ...
        "headers": $util.http.copyHeaders($ctx.request.headers),
        ...
    },
    ...
}
```

**\$1 util.http. addResponseHeader(Stringa, oggetto)**  
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(Map)`, 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 {}
}
```

# Helper XML in \$1util.xml
<a name="xml-helpers-in-utils-xml"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.xml`contiene metodi di supporto che possono semplificare la traduzione delle risposte XML in JSON o in un dizionario.

## Elenco di utilità \$1util.xml
<a name="xml-helpers-in-utils-xml-list"></a>

****`$util.xml.toMap(String) : Map`****  
Converte una stringa XML in un dizionario.  

```
Input:

<?xml version="1.0" encoding="UTF-8"?>
<posts>
<post>
  <id>1</id>
  <title>Getting started with GraphQL</title>
</post>
</posts>

Output (JSON representation):

{
  "posts":{
    "post":{
      "id":1,
      "title":"Getting started with GraphQL"
    }
  }
}


Input:

<?xml version="1.0" encoding="UTF-8"?>
<posts>
<post>
  <id>1</id>
  <title>Getting started with GraphQL</title>
</post>
<post>
  <id>2</id>
  <title>Getting started with AWS AppSync</title>
</post>
</posts>

Output (JSON representation):

{
  "posts":{
    "post":[
        {
          "id":1,
          "title":"Getting started with GraphQL"
        },
        {
          "id":2,
          "title":"Getting started with AWS AppSync"
        }
    ]
  }
}
```

****`$util.xml.toJsonString(String) : 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.

****`$util.xml.toJsonString(String, Boolean) : String`****  
Converte una stringa XML in una stringa JSON con un parametro booleano opzionale per determinare se si desidera codificare il JSON come stringa.

# Aiutanti di trasformazione in \$1util.transform
<a name="transformation-helpers-in-utils-transform"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$util.transform`contiene metodi di supporto che semplificano l'esecuzione di operazioni complesse su fonti di dati, come le operazioni di filtro di Amazon DynamoDB.

## aiutanti per la trasformazione
<a name="transformation-helpers-conversions"></a>

### Elenco di utilità degli aiutanti di trasformazione
<a name="transformation-helpers-in-utils-transform-list"></a>

****`$util.transform.toDynamoDBFilterExpression(Map) : Map`****  
Converte una stringa di input in un'espressione di filtro da utilizzare con DynamoDB.  

```
Input:

$util.transform.toDynamoDBFilterExpression({
    "title":{
      "contains":"Hello World"
    }
  })

Output:

{
    "expression" : "contains(#title, :title_contains)"
    "expressionNames" : {
        "#title" : "title",
    },
    "expressionValues" : {
        ":title_contains" : { "S" : "Hello World" }
    },
}
```

****`$util.transform.toElasticsearchQueryDSL(Map) : Map`****  
Converte l'input specificato nella sua espressione OpenSearch Query DSL equivalente, restituendola come stringa JSON.  

```
Input:

$util.transform.toElasticsearchQueryDSL({
    "upvotes":{
        "ne":15,
        "range":[
            10,
            20
        ]
    },
    "title":{
        "eq":"hihihi",
        "wildcard":"h*i"
    }
  })

Output:
{
    "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.

## Transformation Helpers, filtri di sottoscrizione
<a name="transformation-helpers-conversions-subscription-filters"></a>

### Elenco delle utilità dei filtri di sottoscrizione di Transformation Helpers
<a name="transformation-helpers-in-utils-transform-list"></a>

****`$util.transform.toSubscriptionFilter(Map) : 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).

****`$util.transform.toSubscriptionFilter(Map, List) : Map`****  
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).  
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) : 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).   
Il primo argomento è l'oggetto di `Map` input che viene convertito nell'oggetto `SubscriptionFilter` espressione, il secondo argomento riguarda i nomi `List` di campo che verranno ignorati nel primo oggetto di `Map` input e il terzo argomento è un oggetto di `Map` input con regole rigorose che viene incluso durante la costruzione dell'oggetto `SubscriptionFilter` espressione. Queste regole rigorose sono incluse nell'oggetto `SubscriptionFilter` espressione in modo tale che almeno una delle regole venga soddisfatta per passare il filtro di sottoscrizione.

## Argomenti del filtro di iscrizione
<a name="subscription-filter-arguments"></a>

La tabella seguente spiega come vengono definiti gli argomenti delle seguenti utilità:
+ `$util.transform.toSubscriptionFilter(Map) : Map`
+ `$util.transform.toSubscriptionFilter(Map, List) : Map`
+ `$util.transform.toSubscriptionFilter(Map, List, Map) : Map`

------
#### [ Argument 1: Map ]

L'argomento 1 è un `Map` oggetto con i seguenti valori chiave:
+ nomi di campo
+ «e»
+ «o»

Per i nomi di campo utilizzati come chiavi, le condizioni relative alle 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"
        }
      ]
    }
  ]
}
```

------

# Aiutanti matematici in \$1util.math
<a name="math-helpers-in-util-math"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.math`contiene metodi per facilitare le operazioni matematiche più comuni. 

## lista di utilità \$1util.math
<a name="math-helpers-in-util-math-list"></a>

** `$util.math.roundNum(Double) : Integer` **  
Prende un valore doppio e lo arrotonda al numero intero più vicino. 

** `$util.math.minVal(Double, Double) : Double` **  
Richiede due doppi e restituisce il valore minimo tra i due doppi.

** `$util.math.maxVal(Double, Double) : Double` **  
Richiede due doppi e restituisce il valore massimo tra i due doppi.

** `$util.math.randomDouble() : Double` **  
Restituisce un doppio casuale compreso tra 0 e 1.  
Questa funzione non deve essere utilizzata per nulla che richieda una casualità ad alta entropia (ad esempio, la crittografia).

** `$util.math.randomWithinRange(Integer, Integer) : Integer` **  
Restituisce un valore intero casuale all'interno dell'intervallo specificato, con il primo argomento che specifica il valore inferiore dell'intervallo e il secondo argomento che specifica il valore superiore dell'intervallo.   
Questa funzione non deve essere utilizzata per nulla che richieda una casualità ad alta entropia (ad esempio, la crittografia).

# Aiutanti per le stringhe in \$1util.str
<a name="str-helpers-in-util-str"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

 `$util.str`contiene metodi per facilitare le operazioni più comuni sulle stringhe. 

## Elenco delle utilità di \$1util.str
<a name="str-helpers-in-util-str-list"></a>

** `$util.str.toUpper(String) : String` **  
Prende una stringa e la converte interamente in lettere maiuscole. 

** `$util.str.toLower(String) : String` **  
Prende una stringa e la converte interamente in lettere minuscole.

** `$util.str.toReplace(String, String, String) : String` **  
Sostituisce una sottostringa all'interno di una stringa con un'altra stringa. Il primo argomento specifica la stringa su cui eseguire l'operazione di sostituzione. Il secondo argomento specifica la sottostringa da sostituire. Il terzo argomento specifica la stringa con cui sostituire il secondo argomento. Di seguito è riportato un esempio di utilizzo di questa utilità:   

```
 INPUT:      $util.str.toReplace("hello world", "hello", "mellow")
 OUTPUT:     "mellow world"
```

** `$util.str.normalize(String, 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
<a name="extensions"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

`$extensions`contiene una serie di metodi per eseguire azioni aggiuntive all'interno dei resolver.

## Estensioni di memorizzazione nella cache
<a name="caching-extensions-list"></a>

**`$extensions.evictFromApiCache(String, String, Object) : 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`  
Questa utilità funziona solo per le mutazioni, non per le interrogazioni.

## Estensioni di abbonamento
<a name="subscription-extensions-list"></a>

**`$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 rispondono`true`. L'argomento è `filterJsonObject` descritto nella sezione seguente.  
È possibile utilizzare questo metodo di estensione solo nei modelli di mappatura delle risposte di un resolver di sottoscrizioni.

**`$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 è descritto nella sezione `filterJsonObject` seguente.  
È possibile utilizzare questo metodo di estensione solo nei modelli di mappatura delle risposte di un resolver di sottoscrizioni.

**`$extensions.invalidateSubscriptions(invalidationJsonObject)`**  
Utilizzato per avviare l'invalidazione dell'abbonamento a seguito di una mutazione. L'argomento è `invalidationJsonObject` descritto nella sezione seguente.  
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
<a name="extensions-setSubscriptionInvalidationFilter"></a>

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

### Campo: FieldName
<a name="extensions-fieldName"></a>

Il tipo di stringa `fieldName` si riferisce a un campo definito nello schema GraphQL che corrisponde al `fieldName` payload di notifica della sottoscrizione. Quando viene trovata una corrispondenza, il `value` campo dello schema GraphQL viene confrontato con quello del filtro di notifica `value` della sottoscrizione. Nell'esempio seguente, il `fieldName` filtro corrisponde al `service` campo definito in un determinato tipo GraphQL. Se il payload di notifica contiene un `service` campo con un `value` equivalente a`AWS AppSync`, il filtro restituisce: `true`

```
{
 "fieldName" : "service",
 "operator" : "eq",
 "value" : "AWS AppSync"
}
```

### Campo: valore
<a name="extensions-value"></a>

Il valore può essere di tipo diverso in base all'operatore:
+ Un numero singolo o booleano
  + Esempi di stringhe:, `"test"` `"service"`
  + Esempi di numeri: `1``2`, `45.75`
  + Esempi booleani:, `true` `false`
+ Coppie di numeri o stringhe
  + Esempio di coppia di stringhe:`["test1","test2"]`, `["start","end"]`
  + Esempio di coppia numerica:`[1,4]`,`[67,89]`, `[12.45, 95.45]`
+ Matrici di numeri o stringhe
  + Esempio di array di stringhe: `["test1","test2","test3","test4","test5"]`
  + Esempio di array numerico:`[1,2,3,4,5]`, `[12.11,46.13,45.09,12.54,13.89]`

### Campo: operatore
<a name="extensions-operator"></a>

Una stringa con distinzione tra maiuscole e minuscole con i seguenti valori possibili: 


| 
| 
| Operatore | Description | Tipi di valori possibili | 
| --- |--- |--- |
| eq | Uguale | intero, float, stringa, booleano | 
| uno | Non uguale | intero, float, stringa, booleano | 
| leu | Minore di o uguale a | intero, float, stringa | 
| lt | Less than | intero, float, stringa | 
| età | Maggiore di o uguale a | intero, float, stringa | 
| gt | Greater than | intero, float, stringa | 
| contiene | Verifica la presenza di una sottosequenza o di un valore nel set. | numero intero, float, stringa | 
| Non contiene | Verifica l'assenza di una sottosequenza o l'assenza di un valore nell'insieme. | numero intero, float, stringa | 
| Inizia con | Verifica la presenza di un prefisso. | stringa | 
| in | Verifica la presenza di elementi corrispondenti presenti nell'elenco. | Matrice di numeri interi, float o stringhe | 
| notIn | Verifica la presenza di elementi corrispondenti che non sono presenti nell'elenco. | Matrice di numeri interi, float o stringhe | 
| tra | Tra due valori | numero intero, float, stringa | 
| Contiene Any | Contiene elementi comuni | numero intero, float, stringa | 

La tabella seguente descrive come ogni operatore viene utilizzato nella notifica di sottoscrizione.

------
#### [ eq (equal) ]

L'`eq`operatore valuta `true` se il valore del campo di notifica della sottoscrizione corrisponde ed è strettamente uguale al valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `service` campo con il valore equivalente a. `AWS AppSync`

**Tipi di valori possibili:** integer, float, string, boolean

```
{
 "fieldName" : "service",
 "operator" : "eq",
 "value" : "AWS AppSync"
}
```

------
#### [ ne (not equal) ]

L'`ne`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è diverso dal valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `service` campo con un valore diverso da. `AWS AppSync`

**Tipi di valori possibili:** integer, float, string, boolean

```
{
 "fieldName" : "service",
 "operator" : "ne",
 "value" : "AWS AppSync"
}
```

------
#### [ le (less or equal) ]

L'`le`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è inferiore o uguale al valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `size` campo con un valore inferiore o uguale a. `5`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "size",
 "operator" : "le",
 "value" : 5
}
```

------
#### [ lt (less than) ]

L'`lt`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è inferiore al valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `size` campo con un valore inferiore a. `5`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "size",
 "operator" : "lt",
 "value" : 5
}
```

------
#### [ ge (greater or equal) ]

L'`ge`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è maggiore o uguale al valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `size` campo con un valore maggiore o uguale a. `5`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "size",
 "operator" : "ge",
 "value" : 5
}
```

------
#### [ gt (greater than) ]

L'`gt`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è maggiore del valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `size` campo con un valore maggiore di. `5`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "size",
 "operator" : "gt",
 "value" : 5
}
```

------
#### [ contains ]

L'`contains`operatore verifica la presenza di una sottostringa, di una sottosequenza o di un valore in un set o in un singolo elemento. Un filtro con l'`contains`operatore valuta `true` se il valore del campo di notifica della sottoscrizione contiene il valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `seats` campo con il valore dell'array contenente il valore. `10`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "seats",
 "operator" : "contains",
 "value" : 10
}
```

In un altro esempio, il filtro valuta `true` se la notifica di sottoscrizione ha un `event` campo con `launch` come sottostringa.

```
{
 "fieldName" : "event",
 "operator" : "contains",
 "value" : "launch"
}
```

------
#### [ notContains ]

L'`notContains`operatore verifica l'assenza di una sottostringa, di una sottosequenza o di un valore in un set o in un singolo elemento. Il filtro con l'`notContains`operatore determina `true` se il valore del campo di notifica della sottoscrizione non contiene il valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `seats` campo il cui valore dell'array non contiene il valore. `10`

**Tipi di valori possibili:** integer, float, string

```
{
 "fieldName" : "seats",
 "operator" : "notContains",
 "value" : 10
}
```

In un altro esempio, il filtro valuta `true` se la notifica di sottoscrizione ha un valore di `event` campo senza `launch` come sottofondo.

```
{
 "fieldName" : "event",
 "operator" : "notContains",
 "value" : "launch"
}
```

------
#### [ beginsWith ]

L'`beginsWith`operatore verifica la presenza di un prefisso in una stringa. Il filtro contenente l'`beginsWith`operatore valuta `true` se il valore del campo di notifica della sottoscrizione inizia con il valore del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `service` campo con un valore che inizia con. `AWS`

**Tipo di valore possibile: stringa**

```
{
 "fieldName" : "service",
 "operator" : "beginsWith",
 "value" : "AWS"
}
```

------
#### [ in ]

L'`in`operatore verifica la presenza di elementi corrispondenti in un array. Il filtro contenente l'`in`operatore valuta `true` se il valore del campo di notifica della sottoscrizione esiste in un array. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `severity` campo con uno dei valori presenti nell'array:. `[1,2,3]`

**Tipo di valore possibile:** Array of integer, float o string

```
{
 "fieldName" : "severity",
 "operator" : "in",
 "value" : [1,2,3]
}
```

------
#### [ notIn ]

L'`notIn`operatore verifica la presenza di elementi mancanti in un array. Il filtro contenente l'`notIn`operatore valuta `true` se il valore del campo di notifica della sottoscrizione non esiste nell'array. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `severity` campo con uno dei valori non presenti nell'array:. `[1,2,3]`

**Tipo di valore possibile:** Array di numeri interi, float o string

```
{
 "fieldName" : "severity",
 "operator" : "notIn",
 "value" : [1,2,3]
}
```

------
#### [ between ]

L'`between`operatore verifica la presenza di valori tra due numeri o stringhe. Il filtro contenente l'`between`operatore valuta `true` se il valore del campo di notifica della sottoscrizione è compreso tra la coppia di valori del filtro. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione ha un `severity` campo con valori`2`,,`3`. `4`

**Tipi di valori possibili:** coppia di numeri interi, float o string

```
{
 "fieldName" : "severity",
 "operator" : "between",
 "value" : [1,5]
}
```

------
#### [ containsAny ]

L'`containsAny`operatore verifica la presenza di elementi comuni negli array. Un filtro con l'`containsAny`operatore valuta `true` se l'intersezione tra il valore del set del campo di notifica della sottoscrizione e il valore del set di filtri non è vuota. Nell'esempio seguente, il filtro valuta `true` se la notifica di sottoscrizione contiene un `seats` campo con un valore di matrice contenente o. `10` `15` Ciò significa che il filtro valuterebbe `true` se la notifica di sottoscrizione avesse un valore di `seats` campo pari `[10,11]` o`[15,20,30]`.

**Tipi di valori possibili:** integer, float o string

```
{
 "fieldName" : "seats",
 "operator" : "containsAny",
 "value" : [10, 15]
}
```

------

### Logica AND
<a name="extensions-AND-logic"></a>

È possibile combinare più filtri utilizzando la logica AND definendo più voci all'interno dell'`filters`oggetto dell'`filterGroup`array. Nell'esempio seguente, i filtri valutano `true` se la notifica di sottoscrizione ha un `userId` campo con un valore equivalente a `1` AND un valore di `group` campo pari `Admin` o uguale a`Developer`.

```
{
    "filterGroup": [
        {
           "filters" : [
                 {
                    "fieldName" : "userId",
                    "operator" : "eq",
                    "value" : 1
                },
                {
                    "fieldName" : "group",
                    "operator" : "in",
                    "value" : ["Admin", "Developer"]
                }
           ]
           
        }
    ]
}
```

### Logica OR
<a name="extensions-OR-logic"></a>

È possibile combinare più filtri utilizzando la logica OR definendo più oggetti di filtro all'interno dell'`filterGroup`array. Nell'esempio seguente, i filtri valutano `true` se la notifica di sottoscrizione ha un `userId` campo con un valore equivalente a `1` OR un valore di `group` campo uguale a `Admin` o`Developer`.

```
{
    "filterGroup": [
        {
           "filters" : [
                 {
                    "fieldName" : "userId",
                    "operator" : "eq",
                    "value" : 1
                }
           ]
           
        },
        {
           "filters" : [
                {
                    "fieldName" : "group",
                    "operator" : "in",
                    "value" : ["Admin", "Developer"]
                }
           ]
           
        }
    ]
}
```

### Eccezioni
<a name="extensions-exceptions"></a>

Tieni presente che esistono diverse restrizioni per l'utilizzo dei filtri:
+ Nell'`filters`oggetto, possono esserci un massimo di cinque `fieldName` elementi unici per filtro. Ciò significa che è possibile combinare un massimo di cinque `fieldName` oggetti singoli utilizzando la logica AND.
+ L'`containsAny`operatore può disporre di un massimo di venti valori.
+ Possono esserci un massimo di cinque valori per gli `notIn` operatori `in` and.
+ Ogni stringa può contenere un massimo di 256 caratteri.
+ Ogni confronto tra stringhe distingue tra maiuscole e minuscole.
+ Il filtraggio degli oggetti annidati consente fino a cinque livelli di filtraggio annidati.
+ Ciascuno `filterGroup` può avere un massimo di 10. `filters` Ciò significa che è possibile combinarne un massimo di 10 `filters` utilizzando la logica OR.
  + L'`in`operatore è un caso speciale della logica OR. Nell'esempio seguente, ce ne sono due`filters`:

    ```
    {
        "filterGroup": [
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "in",
                        "value" : ["Admin", "Developer"]
                    }
               ]  
            }
        ]
    }
    ```

    Il gruppo di filtri precedente viene valutato come segue e conta ai fini del limite massimo di filtri:

    ```
    {
        "filterGroup": [
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "eq",
                        "value" : "Admin"
                    }
               ]  
            },
            {
               "filters" : [
                     {
                        "fieldName" : "userId",
                        "operator" : "eq",
                        "value" : 1
                    },
                    {
                        "fieldName" : "group",
                        "operator" : "eq",
                        "value" : "Developer"
                    }
               ]  
            }
        ]
    }
    ```

## Argomento: invalidationJsonObject
<a name="extensions-invalidationJsonObject"></a>

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

  ```
  $extensions.invalidateSubscriptions({
          "subscriptionField": "onUserDelete",
          "payload": {
                  "group": "Developer"
                  "type" : "Full-Time"
        }
      })
  ```

# AWS AppSync riferimento al modello di mappatura dei resolver per DynamoDB
<a name="resolver-mapping-template-reference-dynamodb"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

La funzione AWS AppSync DynamoDB ti consente di utilizzare [GraphQL](https://graphql.org) per archiviare e recuperare dati nelle tabelle Amazon DynamoDB esistenti nel tuo account mappando una richiesta GraphQL in entrata in una chiamata DynamoDB e quindi mappando la risposta DynamoDB a GraphQL. Questa sezione descrive i gestori di richieste e risposte per le operazioni DynamoDB supportate:
+  [GetItem](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-getitem.html)- La GetItem richiesta consente di indicare alla funzione DynamoDB di effettuare una GetItem richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB e se utilizzare o meno una lettura coerente.
+  [ PutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.html)- Il documento di mappatura della PutItem richiesta consente di indicare alla funzione DynamoDB di PutItem effettuare una richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB, il contenuto completo dell'elemento (composto da key e attributeValues) e le condizioni per il successo dell'operazione.
+  [ UpdateItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.html)- La UpdateItem richiesta consente di indicare alla funzione DynamoDB di effettuare una UpdateItem richiesta a DynamoDB e consente di specificare la chiave dell'elemento in DynamoDB, un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB e le condizioni per il successo dell'operazione.
+  [ DeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem.html)- La DeleteItem richiesta consente di indicare alla funzione DynamoDB di effettuare una DeleteItem richiesta a DynamoDB e di specificare la chiave dell'elemento in DynamoDB e le condizioni per il successo dell'operazione.
+  [Query](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-query.html): l'oggetto Query request consente di indicare al resolver DynamoDB di effettuare una richiesta Query a DynamoDB e di specificare l'espressione chiave, l'indice da utilizzare, i filtri aggiuntivi, il numero di elementi da restituire, se utilizzare letture coerenti, la direzione della query (avanti o indietro) e i token di impaginazione.
+  [Scansione](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-scan.html): la richiesta Scan consente di indicare alla funzione DynamoDB di effettuare una richiesta di scansione a DynamoDB e di specificare un filtro per escludere i risultati, quale indice utilizzare, quanti elementi restituire, se utilizzare letture coerenti, token di impaginazione e scansioni parallele.
+  [Sincronizzazione](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-sync.html): l'oggetto di richiesta di sincronizzazione consente di recuperare tutti i risultati da una tabella DynamoDB e quindi ricevere solo i dati modificati dall'ultima query (gli aggiornamenti delta). Le richieste di sincronizzazione possono essere effettuate solo su sorgenti dati DynamoDB con versione. È possibile specificare un filtro per escludere i risultati, il numero di elementi da restituire, i token di paginazione e quando è stata avviata l'ultima operazione di sincronizzazione.
+  [ BatchGetItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item.html)- L'oggetto BatchGetItem request consente di indicare alla funzione DynamoDB di effettuare una BatchGetItem richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle da cui recuperare gli elementi e le chiavi degli elementi da recuperare da ciascuna tabella.
+  [ BatchDeleteItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item.html)- L'oggetto BatchDeleteItem request consente di indicare alla funzione DynamoDB di fare una BatchWriteItem richiesta a DynamoDB per eliminare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle da cui eliminare gli elementi e le chiavi degli elementi da eliminare da ciascuna tabella.
+  [ BatchPutItem ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item.html)- L'oggetto BatchPutItem request consente di indicare alla funzione DynamoDB di fare una BatchWriteItem richiesta a DynamoDB per inserire più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare i nomi delle tabelle in cui inserire gli elementi e gli elementi completi da inserire in ogni tabella.
+  [ TransactGetItems ](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items.html)- L'oggetto TransactGetItems request consente di indicare alla funzione DynamoDB di effettuare una TransactGetItems richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare il nome della tabella di ogni elemento della richiesta da cui recuperare l'elemento e la chiave di ogni elemento della richiesta da recuperare da ogni tabella.
+  [ TransactWriteItems ](https://docs.aws.amazon.com/appsync/latest/devguide/js-aws-appsync-resolver-reference-dynamodb-transact-write-items.html)- L'oggetto TransactWriteItems request consente di indicare alla funzione DynamoDB di TransactWriteItems richiedere a DynamoDB di scrivere più elementi, potenzialmente su più tabelle. Per questo oggetto di richiesta, è necessario specificare il nome della tabella di destinazione di ogni elemento della richiesta, l'operazione di ogni elemento della richiesta da eseguire e la chiave di ogni elemento della richiesta da scrivere.
+  [Sistema dei tipi (mappatura delle richieste)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.html): scopri di più su come la digitazione DynamoDB è integrata nelle richieste. AWS AppSync 
+  [Sistema di tipi (mappatura delle risposte)](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.html): scopri di più su come i tipi DynamoDB vengono convertiti automaticamente in GraphQL o JSON in un payload di risposta.
+  [Filtri](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-filter.html): scopri di più sui filtri per le operazioni di interrogazione e scansione.
+  [Espressioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.html) condizionali: scopri di più sulle espressioni di PutItem condizione e DeleteItem sulle operazioni. UpdateItem
+  [Espressioni delle condizioni delle transazioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.html): ulteriori informazioni sulle espressioni di condizione per TransactWriteItems le operazioni.
+  [Proiezioni](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-resolver-mapping-template-reference-dynamodb-projections.html): ulteriori informazioni su come specificare gli attributi nelle operazioni di lettura.

# GetItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-getitem"></a>

Il documento di mappatura delle `GetItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `GetItem` richiesta a DynamoDB e consente di specificare:
+ La chiave dell'elemento in DynamoDB
+ Se utilizzare una lettura consistente o no

Il documento di mappatura `GetItem` ha la seguente struttura:

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true,
    "projection" : {
        ...
    }
}
```

I campi sono definiti come segue:

## GetItem campi
<a name="getitem-list"></a>

### GetItem elenco dei campi
<a name="getitem-list-col"></a>

 **`version`**   
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

 **`operation`**   
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `GetItem` DynamoDB, il valore deve essere impostato su `GetItem`. Questo valore è obbligatorio.

 **`key`**   
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.

 **`consistentRead`**   
Se eseguire o meno una lettura fortemente coerente con DynamoDB. Si tratta di un'opzione facoltativa, impostata di default su `false`.

**`projection`**  
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.

L'elemento restituito da DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Esempio
<a name="example"></a>

L'esempio seguente è un modello di mappatura per una query `getThing(foo: String!, bar: String!)` GraphQL:

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "consistentRead" : true
}
```

Per ulteriori informazioni sull'API `GetItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html).

# PutItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-putitem"></a>

Il documento di mappatura delle `PutItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `PutItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ L'intero contenuto della voce (costituita da `key` e `attributeValues`)
+ Condizioni per la riuscita dell'operazione

Il documento di mappatura `PutItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "PutItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    },
    "_version" : 1
}
```

I campi sono definiti come segue:

## PutItem campi
<a name="putitem-list"></a>

### PutItem elenco dei campi
<a name="putitem-list-col"></a>

 **`version`**   
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

 **`operation`**   
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `PutItem` DynamoDB, il valore deve essere impostato su `PutItem`. Questo valore è obbligatorio.

 **`key`**   
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.

 **`attributeValues`**   
Gli altri attributi della voce da inserir in DynamoDB. Per ulteriori informazioni su come specificare un «valore digitato», vedete [Type system (request](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) mapping). Questo campo è facoltativo.

 **`condition`**   
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `PutItem` sovrascrive qualsiasi valore esistente per quella voce. Per ulteriori informazioni sulle condizioni, vedere Espressioni di [condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Questo valore è facoltativo.

 **`_version`**   
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.

**`customPartitionKey`**  
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 (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.

**`populateIndexFields`**  
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`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*. Questo campo è facoltativo. 

L'elemento scritto in DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Esempio 1
<a name="example-1"></a>

L'esempio seguente è un modello di mappatura per una mutazione `updateThing(foo: String!, bar: String!, name: String!, version: Int!)` GraphQL.

Se non esiste alcuna voce con la chiave specificata, viene creata. Se esiste, viene sovrascritta.

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "attributeValues" : {
        "name"    : $util.dynamodb.toDynamoDBJson($ctx.args.name),
        "version" : $util.dynamodb.toDynamoDBJson($ctx.args.version)
    }
}
```

## Esempio 2
<a name="example-2"></a>

L'esempio seguente è un modello di mappatura per una mutazione `updateThing(foo: String!, bar: String!, name: String!, expectedVersion: Int!)` GraphQL.

Questo esempio verifica che l'elemento attualmente in DynamoDB abbia `version` il campo impostato su. `expectedVersion`

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : $util.dynamodb.toDynamoDBJson($ctx.args.foo),
        "bar" : $util.dynamodb.toDynamoDBJson($ctx.args.bar)
    },
    "attributeValues" : {
        "name"    : $util.dynamodb.toDynamoDBJson($ctx.args.name),
        #set( $newVersion = $context.arguments.expectedVersion + 1 )
        "version" : $util.dynamodb.toDynamoDBJson($newVersion)
    },
    "condition" : {
        "expression" : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
        }
    }
}
```

Per ulteriori informazioni sull'API `PutItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html).

# UpdateItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem"></a>

Il documento di mappatura delle `UpdateItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `UpdateItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ Un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB
+ Condizioni per la riuscita dell'operazione

Il documento di mappatura `UpdateItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "UpdateItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "update" : {
        "expression" : "someExpression",
        "expressionNames" : {
           "#foo" : "foo"
       },
       "expressionValues" : {
           ":bar" : ... typed value
       }
    },
    "condition" : {
        ...
    },
    "_version" : 1
}
```

I campi sono definiti come segue:

## UpdateItem campi
<a name="updateitem-list"></a>

### UpdateItem elenco dei campi
<a name="updateitem-list-col"></a>

 **`version`**   
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

 **`operation`**   
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `UpdateItem` DynamoDB, il valore deve essere impostato su `UpdateItem`. Questo valore è obbligatorio.

 **`key`**   
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. [Per ulteriori informazioni sulla specificazione di un «valore digitato», consulta Sistema di tipi (mappatura delle richieste).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Questo valore è obbligatorio.

 **`update`**   
La `update` sezione consente di specificare un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Questa sezione è obbligatoria.  
La sezione `update` ha tre componenti:    
** `expression` **  
L'espressione di aggiornamento. Questo valore è obbligatorio.  
** `expressionNames` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato in`expression`, e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.  
** `expressionValues` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Type system](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) (request mapping). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.

 **`condition`**   
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `UpdateItem` aggiorna qualsiasi valore esistente, indipendentemente dal suo stato attuale. Per ulteriori informazioni sulle condizioni, vedere Espressioni di [condizione](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md). Questo valore è facoltativo.

 **`_version`**   
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.

**`customPartitionKey`**  
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 (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.

**`populateIndexFields`**  
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`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*. Questo campo è facoltativo.

L'elemento aggiornato in DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Esempio 1
<a name="id3"></a>

L'esempio seguente è un modello di mappatura per la mutazione `upvote(id: ID!)` GraphQL.

In questo esempio, un elemento in DynamoDB ha i `upvotes` suoi campi `version` e incrementati di 1.

```
{
    "version" : "2017-02-28",
    "operation" : "UpdateItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "update" : {
        "expression" : "ADD #votefield :plusOne, version :plusOne",
        "expressionNames" : {
            "#votefield" : "upvotes"
        },
        "expressionValues" : {
            ":plusOne" : { "N" : 1 }
        }
    }
}
```

## Esempio 2
<a name="id4"></a>

L'esempio seguente è un modello di mappatura per una mutazione `updateItem(id: ID!, title: String, author: String, expectedVersion: Int!)` GraphQL.

Si tratta di un esempio complesso che verifica gli argomenti e genera dinamicamente l'espressione di aggiornamento in cui sono inclusi solo gli argomenti forniti dal client. Ad esempio, se `title` e `author` vengono omessi, non vengono aggiornati. Se viene specificato un argomento ma il suo valore è`null`, quel campo viene eliminato dall'oggetto in DynamoDB. Infine, l'operazione ha una condizione, che verifica se l'elemento attualmente in DynamoDB ha `version` il campo impostato su: `expectedVersion`

```
{
    "version" : "2017-02-28",

    "operation" : "UpdateItem",

    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },

    ## Set up some space to keep track of things we're updating **
    #set( $expNames  = {} )
    #set( $expValues = {} )
    #set( $expSet = {} )
    #set( $expAdd = {} )
    #set( $expRemove = [] )

    ## Increment "version" by 1 **
    $!{expAdd.put("version", ":newVersion")}
    $!{expValues.put(":newVersion", { "N" : 1 })}

    ## Iterate through each argument, skipping "id" and "expectedVersion" **
    #foreach( $entry in $context.arguments.entrySet() )
        #if( $entry.key != "id" && $entry.key != "expectedVersion" )
            #if( (!$entry.value) && ("$!{entry.value}" == "") )
                ## If the argument is set to "null", then remove that attribute from the item in DynamoDB **

                #set( $discard = ${expRemove.add("#${entry.key}")} )
                $!{expNames.put("#${entry.key}", "$entry.key")}
            #else
                ## Otherwise set (or update) the attribute on the item in DynamoDB **

                $!{expSet.put("#${entry.key}", ":${entry.key}")}
                $!{expNames.put("#${entry.key}", "$entry.key")}

                #if( $entry.key == "ups" || $entry.key == "downs" )
                    $!{expValues.put(":${entry.key}", { "N" : $entry.value })}
                #else
                    $!{expValues.put(":${entry.key}", { "S" : "${entry.value}" })}
                #end
            #end
        #end
    #end

    ## Start building the update expression, starting with attributes we're going to SET **
    #set( $expression = "" )
    #if( !${expSet.isEmpty()} )
        #set( $expression = "SET" )
        #foreach( $entry in $expSet.entrySet() )
            #set( $expression = "${expression} ${entry.key} = ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes we're going to ADD **
    #if( !${expAdd.isEmpty()} )
        #set( $expression = "${expression} ADD" )
        #foreach( $entry in $expAdd.entrySet() )
            #set( $expression = "${expression} ${entry.key} ${entry.value}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Continue building the update expression, adding attributes we're going to REMOVE **
    #if( !${expRemove.isEmpty()} )
        #set( $expression = "${expression} REMOVE" )

        #foreach( $entry in $expRemove )
            #set( $expression = "${expression} ${entry}" )
            #if ( $foreach.hasNext )
                #set( $expression = "${expression}," )
            #end
        #end
    #end

    ## Finally, write the update expression into the document, along with any expressionNames and expressionValues **
    "update" : {
        "expression" : "${expression}"
        #if( !${expNames.isEmpty()} )
            ,"expressionNames" : $utils.toJson($expNames)
        #end
        #if( !${expValues.isEmpty()} )
            ,"expressionValues" : $utils.toJson($expValues)
        #end
    },

    "condition" : {
        "expression"       : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($ctx.args.expectedVersion)
        }
    }
}
```

Per ulteriori informazioni sull'API `UpdateItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_UpdateItem.html).

# DeleteItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-deleteitem"></a>

Il documento di mappatura delle `DeleteItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `DeleteItem` richiesta a DynamoDB e consente di specificare quanto segue:
+ La chiave dell'elemento in DynamoDB
+ Condizioni per la riuscita dell'operazione

Il documento di mappatura `DeleteItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "DeleteItem",
    "customPartitionKey" : "foo",
    "populateIndexFields" : boolean value,
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "condition" : {
        ...
    },
    "_version" : 1
}
```

I campi sono definiti come segue:

## DeleteItem campi
<a name="deleteitem-list"></a>

### DeleteItem elenco dei campi
<a name="deleteitem-list-col"></a>

** `version` **  
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `DeleteItem` DynamoDB, il valore deve essere impostato su `DeleteItem`. Questo valore è obbligatorio.

** `key` **  
La chiave dell'elemento in DynamoDB. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. [Per ulteriori informazioni sulla specificazione di un «valore digitato», consulta Sistema di tipi (mappatura delle richieste).](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) Questo valore è obbligatorio.

** `condition` **  
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `DeleteItem` elimina la voce indipendentemente dal suo stato attuale. [Per ulteriori informazioni sulle condizioni, vedere Espressioni di condizione.](aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions.md) Questo valore è facoltativo.

** `_version` **  
Valore numerico che rappresenta l'ultima versione nota di un elemento. Questo valore è facoltativo. Questo campo viene utilizzato per il *rilevamento dei conflitti* ed è supportato solo nelle origini dati con versione.

**`customPartitionKey`**  
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 (per ulteriori informazioni, consulta [Conflict detection and sync](https://docs.aws.amazon.com/appsync/latest/devguide/conflict-detection-and-sync.html) nella *AWS AppSync Developer Guide*). Se abilitata, è abilitata anche l'elaborazione della `populateIndexFields` voce. Questo campo è facoltativo.

**`populateIndexFields`**  
Un valore booleano che, se abilitato **insieme** a`customPartitionKey`, crea nuove voci per ogni record nella tabella delta sync, in particolare nelle colonne `gsi_ds_pk` and`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*. Questo campo è facoltativo. 

L'elemento eliminato da DynamoDB viene automaticamente convertito in tipi primitivi GraphQL e JSON ed è disponibile nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

## Esempio 1
<a name="id6"></a>

L'esempio seguente è un modello di mappatura per una mutazione `deleteItem(id: ID!)` GraphQL. Se esiste già una voce con questo ID, viene eliminata.

```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    }
}
```

## Esempio 2
<a name="id7"></a>

L'esempio seguente è un modello di mappatura per una mutazione `deleteItem(id: ID!, expectedVersion: Int!)` GraphQL. Se esiste già una voce con questo ID, viene eliminata, ma solo se il relativo campo `version` è impostato su `expectedVersion`:

```
{
    "version" : "2017-02-28",
    "operation" : "DeleteItem",
    "key" : {
        "id" : $util.dynamodb.toDynamoDBJson($ctx.args.id)
    },
    "condition" : {
        "expression"       : "attribute_not_exists(id) OR version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : $util.dynamodb.toDynamoDBJson($expectedVersion)
        }
    }
}
```

Per ulteriori informazioni sull'API `DeleteItem` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_DeleteItem.html).

# Query
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-query"></a>

Il documento di mappatura delle `Query` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `Query` richiesta a DynamoDB e consente di specificare quanto segue:
+ Espressione chiave
+ Indice da utilizzare
+ Eventuali filtri aggiuntivi
+ Numero di voci da restituire
+ Se utilizzare letture consistenti
+ Direzione della query (avanti o indietro)
+ Token di paginazione

Il documento di mappatura `Query` ha la seguente struttura:

```
{
    "version" : "2017-02-28",
    "operation" : "Query",
    "query" : {
        "expression" : "some expression",
        "expressionNames" : {
            "#foo" : "foo"
        },
        "expressionValues" : {
            ":bar" : ... typed value
        }
    },
    "index" : "fooIndex",
    "nextToken" : "a pagination token",
    "limit" : 10,
    "scanIndexForward" : true,
    "consistentRead" : false,
    "select" : "ALL_ATTRIBUTES" | "ALL_PROJECTED_ATTRIBUTES" | "SPECIFIC_ATTRIBUTES",
    "filter" : {
        ...
    },
    "projection" : {
        ...
    }
}
```

I campi sono definiti come segue:

## Campi di interrogazione
<a name="query-list"></a>

### Elenco dei campi di interrogazione
<a name="query-list-col"></a>

** `version` **  
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Query` DynamoDB, il valore deve essere impostato su `Query`. Questo valore è obbligatorio.

** `query` **  
La `query` sezione consente di specificare un'espressione di condizione chiave che descrive quali elementi recuperare da DynamoDB. Per ulteriori informazioni su come scrivere espressioni di condizioni chiave, consulta la documentazione di [ KeyConditions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.KeyConditions.html). Questa sezione deve essere specificata.    
** `expression` **  
L'espressione della query. Questo campo deve essere specificato.  
** `expressionNames` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato in`expression`, e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.  
** `expressionValues` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Type system](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) (request mapping). Questo valore è obbligatorio. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.

** `filter` **  
Un ulteriore filtro che può essere utilizzato per filtrare i risultati da DynamoDB prima che siano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.

** `index` **  
Nome dell'indice su cui eseguire una query. L'operazione di interrogazione DynamoDB consente di eseguire la scansione degli indici secondari locali e degli indici secondari globali oltre all'indice della chiave primaria alla ricerca di una chiave hash. Se specificato, indica a DynamoDB di interrogare l'indice specificato. Se omesso, la query viene eseguita sull'indice primario della chiave.

** `nextToken` **  
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.

** `limit` **  
Il numero massimo di item da valutare (non necessariamente il numero di item corrispondenti). Questo campo è facoltativo.

** `scanIndexForward` **  
Un valore booleano che indica se la query deve essere eseguita in avanti o indietro. Si tratta di un campo facoltativo, impostato di default su `true`.

** `consistentRead` **  
Un booleano che indica se utilizzare letture coerenti quando si esegue una query su DynamoDB. Si tratta di un campo facoltativo, impostato di default su `false`.

** `select` **  
Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. Se sono necessari più attributi, puoi impostare questo campo. Questo campo è facoltativo. I valori supportati sono:    
** `ALL_ATTRIBUTES` **  
Restituisce tutti gli attributi della voce nella tabella o nell'indice specificati. 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` **  
Consentito solo durante l'esecuzione di una query su un indice. Recupera tutti gli attributi 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 negli. `projection` `expression` Questo valore restituito equivale a specificare i `projection` `expression` senza specificare alcun valore per. `Select`

**`projection`**  
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.

I risultati di DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

I risultati hanno la struttura seguente:

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10
}
```

I campi sono definiti come segue:

** `items` **  
Un elenco contenente gli elementi restituiti dalla query DynamoDB.

** `nextToken` **  
Se è possibile che ci siano altri risultati, `nextToken` contiene un token di paginazione utilizzabile in un'altra richiesta. Nota che AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, i token di paginazione non possono essere utilizzati con più resolver diversi.

** `scannedCount` **  
Il numero di voci corrispondenti all'espressione di condizione della query prima dell'applicazione di un'espressione di filtro (se presente).

## Esempio
<a name="id9"></a>

L'esempio seguente è un modello di mappatura per una query `getPosts(owner: ID!)` GraphQL.

In questo esempio, un indice secondario globale in una tabella viene interrogato per restituire tutti i post di proprietà dell'ID specificato.

```
{
    "version" : "2017-02-28",
    "operation" : "Query",
    "query" : {
        "expression" : "ownerId = :ownerId",
        "expressionValues" : {
            ":ownerId" : $util.dynamodb.toDynamoDBJson($context.arguments.owner)
        }
    },
    "index" : "owner-index"
}
```

Per ulteriori informazioni sull'API `Query` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html).

# Scan
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-scan"></a>

Il documento di mappatura delle `Scan` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `Scan` richiesta a DynamoDB e consente di specificare quanto segue:
+ Un filtro per escludere i risultati
+ Indice da utilizzare
+ Numero di voci da restituire
+ Se utilizzare letture consistenti
+ Token di paginazione
+ Scansioni parallele

Il documento di mappatura `Scan` ha la seguente struttura:

```
{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "index" : "fooIndex",
    "limit" : 10,
    "consistentRead" : false,
    "nextToken" : "aPaginationToken",
    "totalSegments" : 10,
    "segment" : 1,
    "filter" : {
        ...
    },
    "projection" : {
        ...
    }
}
```

I campi sono definiti come segue:

## Scansiona i campi
<a name="scan-list"></a>

### Elenco dei campi di scansione
<a name="scan-list-col"></a>

** `version` **  
La versione di definizione del modello. Al momento sono supportate le versioni `2017-02-28` e `2018-05-29`. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Scan` DynamoDB, il valore deve essere impostato su `Scan`. Questo valore è obbligatorio.

** `filter` **  
Un filtro che può essere utilizzato per filtrare i risultati di DynamoDB prima che vengano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.

** `index` **  
Nome dell'indice su cui eseguire una query. L'operazione di interrogazione DynamoDB consente di eseguire la scansione degli indici secondari locali e degli indici secondari globali oltre all'indice della chiave primaria alla ricerca di una chiave hash. Se specificato, indica a DynamoDB di interrogare l'indice specificato. Se omesso, la query viene eseguita sull'indice primario della chiave.

** `limit` **  
Numero massimo di elementi da valutare in una sola volta. Questo campo è facoltativo.

** `consistentRead` **  
Un valore booleano che indica se utilizzare letture coerenti quando si esegue una query su DynamoDB. Si tratta di un campo facoltativo, impostato di default su `false`.

** `nextToken` **  
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.

** `select` **  
Per impostazione predefinita, il AWS AppSync resolver DynamoDB restituisce solo gli attributi proiettati nell'indice. Se sono necessari più attributi, è possibile impostare questo campo. Questo campo è facoltativo. I valori supportati sono:    
** `ALL_ATTRIBUTES` **  
Restituisce tutti gli attributi della voce nella tabella o nell'indice specificati. 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` **  
Consentito solo durante l'esecuzione di una query su un indice. Recupera tutti gli attributi 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 negli. `projection` `expression` Questo valore restituito equivale a specificare i `projection` `expression` senza specificare alcun valore per. `Select`

** `totalSegments` **  
Il numero di segmenti in cui partizionare la tabella durante una scansione parallela. Questo campo è facoltativo, ma deve essere specificato se è specificato anche `segment`.

** `segment` **  
Il segmento della tabella in questa operazione quando si esegue una scansione parallela. Questo campo è facoltativo, ma deve essere specificato se è specificato anche `totalSegments`.

**`projection`**  
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.

I risultati restituiti dalla scansione DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

I risultati hanno la struttura seguente:

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10
}
```

I campi sono definiti come segue:

** `items` **  
Un elenco contenente gli elementi restituiti dalla scansione DynamoDB.

** `nextToken` **  
Se potrebbero esserci più risultati, `nextToken` contiene un token di impaginazione che puoi utilizzare in un'altra richiesta. AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, questi token di paginazione non possono essere utilizzati con più resolver diversi.

** `scannedCount` **  
Il numero di elementi recuperati da DynamoDB prima dell'applicazione di un'espressione di filtro (se presente).

## Esempio 1
<a name="id11"></a>

L'esempio seguente è un modello di mappatura per la query GraphQL:. `allPosts`

In questo esempio, vengono restituite tutte le voci della tabella.

```
{
    "version" : "2017-02-28",
    "operation" : "Scan"
}
```

## Esempio 2
<a name="id12"></a>

L'esempio seguente è un modello di mappatura per la query GraphQL:. `postsMatching(title: String!)`

In questo esempio, vengono restituite tutte le voci della tabella il cui titolo inizia con l'argomento `title`.

```
{
    "version" : "2017-02-28",
    "operation" : "Scan",
    "filter" : {
        "expression" : "begins_with(title, :title)",
        "expressionValues" : {
            ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
        },
    }
}
```

Per ulteriori informazioni sull'API `Scan` di DynamoDB, consulta la [documentazione API di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Scan.html).

# Sync
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-sync"></a>

Il documento di mappatura della `Sync` richiesta consente di recuperare tutti i risultati da una tabella DynamoDB e quindi ricevere solo i dati modificati dall'ultima query (gli aggiornamenti delta). `Sync`le richieste possono essere inoltrate solo a sorgenti dati DynamoDB con versione. È possibile specificare quanto segue:
+ Un filtro per escludere i risultati
+ Numero di voci da restituire
+ Token di paginazione
+ Quando è stata avviata l'ultima operazione `Sync`

Il documento di mappatura `Sync` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "Sync",
    "basePartitionKey": "Base Tables PartitionKey",
    "deltaIndexName": "delta-index-name",
    "limit" : 10,
    "nextToken" : "aPaginationToken",
    "lastSync" :  1550000000000,
    "filter" : {
        ...
    }
}
```

I campi sono definiti come segue:

## Sincronizza campi
<a name="sync-list"></a>

### Elenco dei campi di sincronizzazione
<a name="sync-list-col"></a>

** `version` **  
La versione di definizione del modello. Al momento è supportato soltanto `2018-05-29`. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `Sync`, il valore deve essere impostato su `Sync`. Questo valore è obbligatorio.

** `filter` **  
Un filtro che può essere utilizzato per filtrare i risultati di DynamoDB prima che vengano restituiti. Per ulteriori informazioni sui filtri, consulta [Filtri](aws-appsync-resolver-mapping-template-reference-dynamodb-filter.md). Questo campo è facoltativo.

** `limit` **  
Numero massimo di elementi da valutare in una sola volta. Questo campo è facoltativo. Se omesso, il limite predefinito sarà impostato su `100` elementi. Il valore massimo per questo campo è `1000` articoli.

** `nextToken` **  
Il token di paginazione utilizzato per continuare una query precedente, dalla quale deve essere ottenuto. Questo campo è facoltativo.

** `lastSync` **  
Il momento, in millisecondi dall'epoca, in cui è iniziata l'ultima operazione `Sync` riuscita. Se specificato, vengono restituiti solo gli elementi che sono stati modificati dopo `lastSync`. Questo campo è facoltativo e deve essere compilato solo dopo aver recuperato tutte le pagine da un' operazione `Sync` iniziale. Se omesso, i risultati della tabella *Base* verranno restituiti, altrimenti verranno restituiti i risultati della tabella *Delta*.

**`basePartitionKey`**  
La chiave di partizione della tabella *Base* utilizzata durante l'esecuzione di un'operazione. `Sync` Questo campo consente di eseguire un'`Sync`operazione quando la tabella utilizza una chiave di partizione personalizzata. Questo campo è opzionale.

**`deltaIndexName`**  
L'indice utilizzato per l'operazione. `Sync` Questo indice è necessario per abilitare un'`Sync`operazione sull'intera tabella delta store quando la tabella utilizza una chiave di partizione personalizzata. L'`Sync`operazione verrà eseguita sul GSI (creato su `gsi_ds_pk` and`gsi_ds_sk`). Questo campo è facoltativo.

I risultati restituiti dalla sincronizzazione DynamoDB vengono convertiti automaticamente in tipi primitivi GraphQL e JSON e sono disponibili nel contesto di mappatura (). `$context.result`

Per ulteriori informazioni sulla conversione dei tipi in DynamoDB, [vedere Sistema dei tipi (](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses.md)mappatura delle risposte).

Per ulteriori informazioni sui modelli di mappatura delle risposte, consulta Panoramica dei modelli di mappatura [Resolver](resolver-mapping-template-reference-overview.md#aws-appsync-resolver-mapping-template-reference-overview).

I risultati hanno la struttura seguente:

```
{
    items = [ ... ],
    nextToken = "a pagination token",
    scannedCount = 10,
    startedAt = 1550000000000
}
```

I campi sono definiti come segue:

** `items` **  
Un elenco contenente le voci restituite dalla sincronizzazione.

** `nextToken` **  
Se potrebbero esserci più risultati, `nextToken` contiene un token di impaginazione che puoi utilizzare in un'altra richiesta. AWS AppSync crittografa e offusca il token di impaginazione restituito da DynamoDB. In questo modo si evita che i dati della tabella siano inavvertitamente divulgati all'intermediario. Inoltre, questi token di paginazione non possono essere utilizzati con più resolver diversi.

** `scannedCount` **  
Il numero di elementi recuperati da DynamoDB prima dell'applicazione di un'espressione di filtro (se presente).

** `startedAt` **  
Il momento, in millisecondi dall'epoca, in cui è iniziata l'operazione di sincronizzazione che è possibile memorizzare localmente e utilizzare in un'altra richiesta come argomento `lastSync`. Se un token di paginazione è stato incluso nella richiesta, questo valore sarà lo stesso di quello restituito dalla richiesta per la prima pagina di risultati.

## Esempio
<a name="id14"></a>

L'esempio seguente è un modello di mappatura per la query GraphQL:. `syncPosts(nextToken: String, lastSync: AWSTimestamp)`

In questo esempio, se `lastSync` viene omesso, vengono restituite tutte le voci nella tabella di base. Se `lastSync` viene fornito, vengono restituite solo le voci nella tabella di sincronizzazione delta che sono state modificate dal momento in cui sono state sincronizzate `lastSync`.

```
{
    "version" : "2018-05-29",
    "operation" : "Sync",
    "limit": 100,
    "nextToken": $util.toJson($util.defaultIfNull($ctx.args.nextToken, null)),
    "lastSync": $util.toJson($util.defaultIfNull($ctx.args.lastSync, null))
}
```

# BatchGetItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-get-item"></a>

Il documento di mappatura delle `BatchGetItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `BatchGetItem` richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle da cui recuperare le voci
+ Le chiavi delle voci da recuperare da ciascuna tabella

Si applicano i limiti `BatchGetItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.

Il documento di mappatura `BatchGetItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "BatchGetItem",
    "tables" : {
        "table1": {
           "keys": [
              ## Item to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              },
              ## Item2 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              }
            ],
            "consistentRead": true|false,            
            "projection" : {
                 ...
            }
        },
        "table2": {
           "keys": [
              ## Item3 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              },
              ## Item4 to retrieve Key
              {
                   "foo" : ... typed value,
                   "bar" : ... typed value
              }
            ],
            "consistentRead": true|false,
            "projection" : {
                 ...
            }
        }
    }
}
```

I campi sono definiti come segue:

## BatchGetItem campi
<a name="BatchGetItem-list"></a>

### BatchGetItem elenco dei campi
<a name="BatchGetItem-list-col"></a>

** `version` **  
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchGetItem` DynamoDB, il valore deve essere impostato su `BatchGetItem`. Questo valore è obbligatorio.

** `tables` **  
Le tabelle DynamoDB da cui recuperare gli elementi. Il valore è una mappa in cui i nomi delle tabelle sono specificati come chiavi della mappa. Occorre specificare almeno una tabella. Questo valore `tables` è obbligatorio.    
** `keys` **  
Elenco di chiavi DynamoDB che rappresentano la chiave primaria degli elementi da recuperare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).  
** `consistentRead` **  
Se utilizzare una lettura coerente durante l'esecuzione di un'*GetItem*operazione. Questo valore è opzionale e l'impostazione predefinita è *false*.  
**`projection`**  
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.

Aspetti da ricordare:
+ Se una voce non è stata recuperata dalla tabella, un elemento *null* compare nel blocco di dati relativo a quella tabella.
+ I risultati delle chiamate vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Get` comando all'interno di a `BatchGetItem` è atomico, tuttavia un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+  `BatchGetItem` ha un limite di 100 chiavi.

Per il seguente esempio di modello di mappatura della richiesta:

```
{
  "version": "2018-05-29",
  "operation": "BatchGetItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          }
        }
    ],
  }
}
```

Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:

```
{
   "data": {
     "authors": [null],
     "posts": [
        # Was retrieved
        {
          "author_id": "a1",
          "post_id": "p2",
          "post_title": "title",
          "post_description": "description",
        }
     ]
   },
   "unprocessedKeys": {
     "authors": [
        # This item was not processed due to an error
        {
          "author_id": "a1"
        }
      ],
     "posts": []
   }
}
```

Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedKeys** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci eliminate compaiono nel blocco **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedKeys**.

Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.

# BatchDeleteItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-delete-item"></a>

Il documento di mappatura delle `BatchDeleteItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `BatchWriteItem` richiesta a DynamoDB per eliminare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle da cui eliminare le voci
+ Le chiavi delle voci da eliminare da ciascuna tabella

Si applicano i limiti `BatchWriteItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.

Il documento di mappatura `BatchDeleteItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "BatchDeleteItem",
    "tables" : {
        "table1": [
        ## Item to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item2 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
        "table2": [
        ## Item3 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item4 to delete Key
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
    }
}
```

I campi sono definiti come segue:

## BatchDeleteItem campi
<a name="BatchDeleteItem-list"></a>

### BatchDeleteItem elenco dei campi
<a name="BatchDeleteItem-list-col"></a>

** `version` **  
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchDeleteItem` DynamoDB, il valore deve essere impostato su `BatchDeleteItem`. Questo valore è obbligatorio.

** `tables` **  
Le tabelle DynamoDB da cui eliminare gli elementi. Ogni tabella è un elenco di chiavi DynamoDB che rappresentano la chiave primaria degli elementi da eliminare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Occorre specificare almeno una tabella. Il `tables` valore è obbligatorio.

Aspetti da ricordare:
+ A differenza dell'operazione `DeleteItem`, nella risposta non viene restituita la voce completamente eliminata. Viene restituita solo la chiave passata.
+ Se una voce non è stata eliminata dalla tabella, un elemento *null* compare nel blocco di dati relativo a quella tabella.
+ I risultati delle chiamate vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Delete` comando all'interno di a è atomico. `BatchDeleteItem` Tuttavia, un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+  `BatchDeleteItem` ha un limite di 25 chiavi.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.

Per il seguente esempio di modello di mappatura della richiesta:

```
{
  "version": "2018-05-29",
  "operation": "BatchDeleteItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          }
        }
    ],
  }
}
```

Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:

```
{
   "data": {
     "authors": [null],
     "posts": [
        # Was deleted
        {
          "author_id": "a1",
          "post_id": "p2"
        }
     ]
   },
   "unprocessedKeys": {
     "authors": [
        # This key was not processed due to an error
        {
          "author_id": "a1"
        }
      ],
     "posts": []
   }
}
```

Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedKeys** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci eliminate sono presenti nel blocco di **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedKeys**.

Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.

# BatchPutItem
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-batch-put-item"></a>

Il documento di mappatura delle `BatchPutItem` richieste consente di indicare al AWS AppSync resolver DynamoDB di fare una `BatchWriteItem` richiesta a DynamoDB per inserire più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ I nomi delle tabelle in cui inserire le voci
+ Le voci complete da inserire in ciascuna tabella

Si applicano i limiti `BatchWriteItem` di DynamoDB e non si può inserire **alcuna espressione di condizione**.

Il documento di mappatura `BatchPutItem` ha la seguente struttura:

```
{
    "version" : "2018-05-29",
    "operation" : "BatchPutItem",
    "tables" : {
        "table1": [
        ## Item to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item2 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
        "table2": [
        ## Item3 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        },
        ## Item4 to put
        {
             "foo" : ... typed value,
             "bar" : ... typed value
        }],
    }
}
```

I campi sono definiti come segue:

## BatchPutItem campi
<a name="BatchPutItem-list"></a>

### BatchPutItem elenco dei campi
<a name="BatchPutItem-list-col"></a>

** `version` **  
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `BatchPutItem` DynamoDB, il valore deve essere impostato su `BatchPutItem`. Questo valore è obbligatorio.

** `tables` **  
Le tabelle DynamoDB in cui inserire gli elementi. Ogni voce della tabella rappresenta un elenco di elementi DynamoDB da inserire per questa tabella specifica. Occorre specificare almeno una tabella. Questo valore è obbligatorio.

Aspetti da ricordare:
+ Se l'operazione va a buon fine, nella risposta vengono restituite le voci inserite completamente.
+ Se una voce non è stata inserita nella tabella, un elemento *null* viene visualizzato nel blocco di dati relativo a quella tabella.
+ Gli elementi inseriti vengono ordinati per tabella, in base all'ordine in cui sono stati forniti all'interno del modello di mappatura della richiesta.
+ Ogni `Put` comando all'interno di a `BatchPutItem` è atomico, tuttavia un batch può essere parzialmente elaborato. Se un batch viene elaborato parzialmente a causa di un errore, le chiavi non elaborate vengono restituite nell'ambito del risultato dell'invocazione all'interno del blocco *unprocessedKeys*.
+  `BatchPutItem` ha un limite di 25 voci.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.

Per il seguente esempio di modello di mappatura della richiesta:

```
{
  "version": "2018-05-29",
  "operation": "BatchPutItem",
  "tables": {
    "authors": [
        {
          "author_id": {
            "S": "a1"
          },
          "author_name": {
            "S": "a1_name"
          }
        },
    ],
    "posts": [
        {
          "author_id": {
            "S": "a1"
          },
          "post_id": {
            "S": "p2"
          },
          "post_title": {
            "S": "title"
          }
        }
    ],
  }
}
```

Il risultato dell'invocazione disponibile in `$ctx.result` è il seguente:

```
{
   "data": {
     "authors": [
         null
     ],
     "posts": [
        # Was inserted
        {
          "author_id": "a1",
          "post_id": "p2",
          "post_title": "title"
        }
     ]
   },
   "unprocessedItems": {
     "authors": [
        # This item was not processed due to an error
        {
          "author_id": "a1",
          "author_name": "a1_name"
        }
      ],
     "posts": []
   }
}
```

Il messaggio `$ctx.error` contiene dettagli relativi all'errore. Le chiavi **dati**, **unprocessedItems** e ogni chiave di tabella disponibile nel modello di mappatura della richiesta sono sicuramente presenti nel risultato dell'invocazione. Le voci inserite si trovano nel blocco di **dati**. Le voci non elaborate vengono contrassegnate come *null* all'interno del blocco dati e vengono inserite nel blocco **unprocessedItems**.

Per un esempio più completo, segui il tutorial su DynamoDB Batch [con AppSync questo Tutorial: DynamoDB](tutorial-dynamodb-batch.md#aws-appsync-tutorial-dynamodb-batch) batch resolvers.

# TransactGetItems
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transact-get-items"></a>

Il documento di mappatura delle `TransactGetItems` richieste consente di indicare al AWS AppSync resolver DynamoDB di effettuare una `TransactGetItems` richiesta a DynamoDB per recuperare più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ Il nome della tabella di ogni elemento di richiesta da cui recuperare l'elemento
+ La chiave di ogni elemento di richiesta da recuperare da ogni tabella

Si applicano i limiti `TransactGetItems` di DynamoDB e non si può inserire **alcuna espressione di condizione**.

Il documento di mappatura `TransactGetItems` ha la seguente struttura:

```
{
    "version": "2018-05-29",
    "operation": "TransactGetItems",
    "transactItems": [
       ## First request item
       {
           "table": "table1",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "projection" : {
                ...
           }
       },
       ## Second request item
       {
           "table": "table2",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "projection" : {
                ...
           }
       }
    ]
}
```

I campi sono definiti come segue:

## TransactGetItems campi
<a name="TransactGetItems-list"></a>

### TransactGetItems elenco dei campi
<a name="TransactGetItems-list-col"></a>

** `version` **  
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.

** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `TransactGetItems` DynamoDB, il valore deve essere impostato su `TransactGetItems`. Questo valore è obbligatorio.

** `transactItems` **  
Gli elementi di richiesta da includere. Il valore è un array di elementi di richiesta. Deve essere fornito almeno un elemento di richiesta. Questo valore `transactItems` è obbligatorio.    
** `table` **  
La tabella DynamoDB da cui recuperare l'elemento. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.  
** `key` **  
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da recuperare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)).  
**`projection`**  
Una proiezione utilizzata per specificare gli attributi da restituire dall'operazione DynamoDB. [Per ulteriori informazioni sulle proiezioni, vedere Proiezioni.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-mapping-template-reference-dynamodb.html#aws-appsync-resolver-mapping-template-reference-dynamodb-projections) Questo campo è facoltativo.

Aspetti da ricordare:
+ Se una transazione ha esito positivo, l'ordine degli elementi recuperati nel blocco `items` sarà lo stesso dell'ordine degli elementi della richiesta.
+ Le transazioni vengono eseguite in qualche modo. all-or-nothing Se un elemento di richiesta causa un errore, l'intera transazione non viene eseguita e vengono restituiti i dettagli dell'errore.
+ Un elemento di richiesta che non può essere recuperato non è un errore. Invece, un elemento *null* appare nel blocco *elementi* nella posizione corrispondente.
+ Se l'errore di una transazione è *TransactionCanceledException*, il `cancellationReasons` blocco verrà popolato. L'ordine dei motivi di annullamento nel blocco `cancellationReasons` è lo stesso dell'ordine degli elementi della richiesta.
+  `TransactGetItems`è limitato a 100 articoli richiesti.

Per il seguente esempio di modello di mappatura della richiesta:

```
{
    "version": "2018-05-29",
    "operation": "TransactGetItems",
    "transactItems": [
       ## First request item
       {
           "table": "posts",
           "key": {
               "post_id": {
                 "S": "p1"
               }
           }
       },
       ## Second request item
       {
           "table": "authors",
           "key": {
               "author_id": {
                 "S": a1
               }
           }
       }
    ]
}
```

Se la transazione ha esito positivo e viene recuperato solo il primo elemento richiesto, il risultato della chiamata disponibile `$ctx.result` è il seguente:

```
{
    "items": [
       {
           // Attributes of the first requested item
           "post_id": "p1",
           "post_title": "title",
           "post_description": "description"
       },
       // Could not retrieve the second requested item
       null,
    ],
    "cancellationReasons": null
}
```

Se la transazione fallisce a *TransactionCanceledException*causa del primo elemento della richiesta, il risultato della chiamata disponibile in `$ctx.result` è il seguente:

```
{
    "items": null,
    "cancellationReasons": [
       {
           "type":"Sample error type",
           "message":"Sample error message"
       },
       {
           "type":"None",
           "message":"None"
       }
    ]
}
```

Il messaggio `$ctx.error` contiene dettagli relativi all'errore. La presenza delle chiavi **items** e **cancellationReasons** è garantita in `$ctx.result`.

Per un esempio più completo, segui il tutorial sulle transazioni di DynamoDB AppSync con questo [Tutorial: risolutori di transazioni DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).

# TransactWriteItems
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transact-write-items"></a>

Il documento di mappatura delle `TransactWriteItems` richieste consente di indicare al AWS AppSync resolver DynamoDB di `TransactWriteItems` richiedere a DynamoDB di scrivere più elementi, potenzialmente su più tabelle. Per questo modello di richiesta, è necessario specificare quanto segue:
+ Il nome della tabella di destinazione di ogni elemento di richiesta
+ L'operazione di ogni elemento di richiesta da eseguire. Sono supportati quattro tipi di operazioni:,, e *PutItem*UpdateItem*DeleteItem*ConditionCheck**** 
+ La chiave di ogni elemento di richiesta da scrivere

Si applicano i limiti `TransactWriteItems` DynamoDB.

Il documento di mappatura `TransactWriteItems` ha la seguente struttura:

```
{
    "version": "2018-05-29",
    "operation": "TransactWriteItems",
    "transactItems": [
       {
           "table": "table1",
           "operation": "PutItem",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "attributeValues": {
               "baz": ... typed value
           },
           "condition": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table":"table2",
           "operation": "UpdateItem",
           "key": {
               "foo": ... typed value,
               "bar": ... typed value
           },
           "update": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               }
           },
           "condition": {
               "expression": "someExpression",
               "expressionNames": {
                   "#foo":"foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table": "table3",
           "operation": "DeleteItem",
           "key":{
               "foo": ... typed value,
               "bar": ... typed value
           },
           "condition":{
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       },
       {
           "table": "table4",
           "operation": "ConditionCheck",
           "key":{
               "foo": ... typed value,
               "bar": ... typed value
           },
           "condition":{
               "expression": "someExpression",
               "expressionNames": {
                   "#foo": "foo"
               },
               "expressionValues": {
                   ":bar": ... typed value
               },
               "returnValuesOnConditionCheckFailure": true|false
           }
       }
    ]
}
```

## TransactWriteItems campi
<a name="TransactWriteItems-list"></a>

### TransactWriteItems elenco dei campi
<a name="TransactWriteItems-list-col"></a>

**I campi sono definiti come segue:**    
** `version` **  
La versione di definizione del modello. Solo `2018-05-29`è supportata. Questo valore è obbligatorio.  
** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `TransactWriteItems` DynamoDB, il valore deve essere impostato su `TransactWriteItems`. Questo valore è obbligatorio.  
** `transactItems` **  
Gli elementi di richiesta da includere. Il valore è un array di elementi di richiesta. Deve essere fornito almeno un elemento di richiesta. Questo valore `transactItems` è obbligatorio.  
Per `PutItem`, i campi sono definiti come segue:    
** `table` **  
La tabella DynamoDB di destinazione. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.  
** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `PutItem` DynamoDB, il valore deve essere impostato su `PutItem`. Questo valore è obbligatorio.  
** `key` **  
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da inserire. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.  
** `attributeValues` **  
Gli altri attributi della voce da inserir in DynamoDB. Per ulteriori informazioni su come specificare un «valore digitato», vedete [Type system (request](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md) mapping). Questo campo è facoltativo.  
** `condition` **  
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `PutItem` sovrascrive qualsiasi valore esistente per quella voce. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `UpdateItem`, i campi sono definiti come segue:    
** `table` **  
La tabella DynamoDB da aggiornare. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.  
** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `UpdateItem` DynamoDB, il valore deve essere impostato su `UpdateItem`. Questo valore è obbligatorio.  
** `key` **  
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da aggiornare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.  
** `update` **  
La `update` sezione consente di specificare un'espressione di aggiornamento che descrive come aggiornare l'elemento in DynamoDB. Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di [ UpdateExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.UpdateExpressions.html). Questa sezione è obbligatoria.  
** `condition` **  
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `UpdateItem` aggiorna qualsiasi valore esistente, indipendentemente dal suo stato attuale. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `DeleteItem`, i campi sono definiti come segue:    
** `table` **  
La tabella DynamoDB in cui eliminare l'elemento. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.  
** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `DeleteItem` DynamoDB, il valore deve essere impostato su `DeleteItem`. Questo valore è obbligatorio.  
** `key` **  
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento da eliminare. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.  
** `condition` **  
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. Se non viene specificata alcuna condizione, la richiesta `DeleteItem` elimina la voce indipendentemente dal suo stato attuale. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è facoltativo.
Per `ConditionCheck`, i campi sono definiti come segue:    
** `table` **  
La tabella DynamoDB in cui controllare la condizione. Il valore è una stringa del nome della tabella. Questo valore `table` è obbligatorio.  
** `operation` **  
L'operazione DynamoDB da eseguire. Per eseguire l'operazione `ConditionCheck` DynamoDB, il valore deve essere impostato su `ConditionCheck`. Questo valore è obbligatorio.  
** `key` **  
La chiave DynamoDB che rappresenta la chiave primaria dell'elemento per il controllo delle condizioni. Gli elementi DynamoDB possono avere una sola chiave hash o una chiave hash e una chiave di ordinamento, a seconda della struttura della tabella. Per ulteriori informazioni su come specificare un «valore digitato», consulta [Sistema di tipi (mappatura delle richieste](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md)). Questo valore è obbligatorio.  
** `condition` **  
Una condizione per determinare se la richiesta deve riuscire o no in base allo stato dell'oggetto già incluso in DynamoDB. È possibile specificare se recuperare l'elemento esistente quando il controllo delle condizioni non riesce. [Per ulteriori informazioni sulle condizioni transazionali, consulta Espressioni delle condizioni di transazione.](aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions.md) Questo valore è obbligatorio.

Aspetti da ricordare:
+ Solo le chiavi degli elementi della richiesta vengono restituite nella risposta, in caso di esito positivo. L'ordine delle chiavi sarà lo stesso dell'ordine degli elementi della richiesta.
+ Le transazioni vengono eseguite in qualsiasi modo. all-or-nothing Se un elemento di richiesta causa un errore, l'intera transazione non viene eseguita e vengono restituiti i dettagli dell'errore.
+ Nessun elemento di richiesta può scegliere come target lo stesso elemento. Altrimenti causeranno *TransactionCanceledException*errori.
+ Se l'errore di una transazione è *TransactionCanceledException*, il `cancellationReasons` blocco verrà popolato. Se il controllo delle condizioni di un elemento di richiesta fallisce **e** non è stato specificato `returnValuesOnConditionCheckFailure` come `false`, l'elemento esistente nella tabella viene recuperato e memorizzato in `item` nella posizione corrispondente del blocco `cancellationReasons`.
+  `TransactWriteItems`è limitato a 100 articoli richiesti.
+ Questa operazione **non è** supportata se utilizzata con il rilevamento dei conflitti. L'utilizzo di entrambi allo stesso tempo può causare un errore.

Per il seguente esempio di modello di mappatura della richiesta:

```
{
    "version": "2018-05-29",
    "operation": "TransactWriteItems",
    "transactItems": [
       {
           "table": "posts",
           "operation": "PutItem",
           "key": {
               "post_id": {
                   "S": "p1"
               }
           },
           "attributeValues": {
               "post_title": {
                   "S": "New title"
               },
               "post_description": {
                   "S": "New description"
               }
           },
           "condition": {
               "expression": "post_title = :post_title",
               "expressionValues": {
                   ":post_title": {
                       "S": "Expected old title"
                   }
               }
           }
       },
       {
           "table":"authors",
           "operation": "UpdateItem",
           "key": {
               "author_id": {
                   "S": "a1"
               },
           },
           "update": {
               "expression": "SET author_name = :author_name",
               "expressionValues": {
                   ":author_name": {
                       "S": "New name"
                   }
               }
           },
       }
    ]
}
```

Se la transazione ha esito positivo, il risultato della chiamata disponibile in `$ctx.result` è il seguente:

```
{
    "keys": [
       // Key of the PutItem request
       {
           "post_id": "p1",
       },
       // Key of the UpdateItem request
       {
           "author_id": "a1"
       }
    ],
    "cancellationReasons": null
}
```

Se la transazione fallisce a causa del fallimento del controllo delle condizioni della `PutItem` richiesta, il risultato della chiamata disponibile in `$ctx.result` è il seguente:

```
{
    "keys": null,
    "cancellationReasons": [
       {
           "item": {
               "post_id": "p1",
               "post_title": "Actual old title",
               "post_description": "Old description"
           },
           "type": "ConditionCheckFailed",
           "message": "The condition check failed."
       },
       {
           "type": "None",
           "message": "None"
       }
    ]
}
```

Il messaggio `$ctx.error` contiene dettagli relativi all'errore. La presenza delle chiavi **keys** e **cancellationReasons** è garantita in `$ctx.result`.

Per un esempio più completo, segui il tutorial sulle transazioni di DynamoDB AppSync con questo [Tutorial: risolutori di transazioni DynamoDB](tutorial-dynamodb-transact.md#aws-appsync-tutorial-dynamodb-transact).

# Sistema di tipi (mappatura delle richieste)
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request"></a>

Quando si utilizza il AWS AppSync resolver DynamoDB per chiamare le AWS AppSync tabelle DynamoDB, è necessario conoscere il tipo di ogni valore da utilizzare in quella chiamata. Questo perché DynamoDB supporta più primitive di tipo rispetto a GraphQL o JSON (come set e dati binari). AWS AppSync necessita di alcuni suggerimenti per la traduzione tra GraphQL e DynamoDB, altrimenti dovrebbe formulare alcune ipotesi su come i dati sono strutturati nella tabella.

[Per ulteriori informazioni sui tipi di dati DynamoDB, consulta i descrittori dei tipi di dati e la documentazione sui tipi di dati di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Programming.LowLevelAPI.html#Programming.LowLevelAPI.DataTypeDescriptors).](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes)

Un valore DynamoDB è rappresentato da un oggetto JSON contenente una singola coppia chiave-valore. La chiave specifica il tipo DynamoDB e il valore specifica il valore stesso. In questo esempio, la chiave `S` indica che il valore è una stringa e il valore `identifier` è il valore della stringa stessa.

```
{ "S" : "identifier" }
```

L'oggetto JSON non può contenere più di una coppia chiave-valore. In caso contrario, il documento di mappatura della richiesta non viene analizzato.

Un valore DynamoDB viene utilizzato ovunque in un documento di mappatura delle richieste in cui è necessario specificare un valore. ad esempio nelle sezioni `key` e `attributeValue`, nonché nella sezione `expressionValues` delle sezioni delle espressioni. Nell'esempio seguente, il `identifier` valore String di DynamoDB viene assegnato al campo in una sezione (magari in `key` `GetItem` un documento di mappatura `id` della richiesta).

```
"key" : {
   "id" : { "S" : "identifier" }
}
```

 **Tipi supportati** 

AWS AppSync supporta i seguenti tipi di scalari, documenti e set di DynamoDB:

**`S` (tipo String) **  
Un singolo valore di stringa. Un valore di stringa DynamoDB è indicato da:  

```
{ "S" : "some string" }
```
Un esempio di utilizzo è:  

```
"key" : {
   "id" : { "S" : "some string" }
}
```

**`SS` (tipo String set) **  
Un set di valori di stringa. Un valore DynamoDB String Set è indicato da:  

```
{ "SS" : [ "first value", "second value", ... ] }
```
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "phoneNumbers" : { "SS" : [ "+1 555 123 4567", "+1 555 234 5678" ] }
}
```

**`N` (tipo Number) **  
Un singolo valore numerico. Un valore numerico di DynamoDB è indicato da:  

```
{ "N" : 1234 }
```
Un esempio di utilizzo è:  

```
"expressionValues" : {
   ":expectedVersion" : { "N" : 1 }
}
```

**`NS` (tipo Number set) **  
Un set di valori numerici. Un valore del DynamoDB Number Set è indicato da:  

```
{ "NS" : [ 1, 2.3, 4 ... ] }
```
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "sensorReadings" : { "NS" : [ 67.8, 12.2, 70 ] }
}
```

**`B` (tipo Binary) **  
Un valore binario. Un valore binario di DynamoDB è indicato da:  

```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
Nota che il valore è in realtà una stringa, dove la stringa è la rappresentazione codificata in base64 dei dati binari. AWS AppSync decodifica nuovamente questa stringa nel suo valore binario prima di inviarla a DynamoDB. AWS AppSync utilizza lo schema di decodifica base64 come definito da RFC 2045: qualsiasi carattere che non sia nell'alfabeto base64 viene ignorato.  
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "binaryMessage" : { "B" : "SGVsbG8sIFdvcmxkIQo=" }
}
```

**`BS` (tipo Binary set) **  
Un set di valori binari. Un valore del set binario di DynamoDB è indicato da:  

```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
Nota che il valore è in realtà una stringa, dove la stringa è la rappresentazione codificata in base64 dei dati binari. AWS AppSync decodifica nuovamente questa stringa nel suo valore binario prima di inviarla a DynamoDB. AWS AppSync utilizza lo schema di decodifica base64 come definito da RFC 2045: qualsiasi carattere che non sia nell'alfabeto base64 viene ignorato.  
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "binaryMessages" : { "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ] }
}
```

**`BOOL` (tipo Boolean) **  
Un valore booleano. Un valore booleano di DynamoDB è indicato da:  

```
{ "BOOL" : true }
```
Solo i valori `true` e `false` sono validi.  
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "orderComplete" : { "BOOL" : false }
}
```

**`L` (tipo List) **  
Un elenco di qualsiasi altro valore DynamoDB supportato. Un valore di DynamoDB List è indicato da:  

```
{ "L" : [ ... ] }
```
Nota che il valore è un valore composto, in cui l'elenco può contenere zero o più di qualsiasi valore DynamoDB supportato (inclusi altri elenchi). L'elenco può anche contenere una combinazione di diversi tipi.  
Un esempio di utilizzo è:  

```
{ "L" : [
      { "S"  : "A string value" },
      { "N"  : 1 },
      { "SS" : [ "Another string value", "Even more string values!" ] }
   ]
}
```

**`M` (tipo Map) **  
Rappresenta una raccolta non ordinata di coppie chiave-valore di altri valori DynamoDB supportati. Un valore di DynamoDB Map è indicato da:  

```
{ "M" : { ... } }
```
Una mappa può contenere zero o più coppie chiave-valore. La chiave deve essere una stringa e il valore può essere qualsiasi valore DynamoDB supportato (incluse altre mappe). La mappa può anche contenere una combinazione di diversi tipi.  
Un esempio di utilizzo è:  

```
{ "M" : {
      "someString" : { "S"  : "A string value" },
      "someNumber" : { "N"  : 1 },
      "stringSet"  : { "SS" : [ "Another string value", "Even more string values!" ] }
   }
}
```

**`NULL` (tipo Null) **  
Un valore nullo. Un valore Null di DynamoDB è indicato da:  

```
{ "NULL" : null }
```
Un esempio di utilizzo è:  

```
"attributeValues" : {
   "phoneNumbers" : { "NULL" : null }
}
```

Per ulteriori informazioni su ciascun tipo, consulta la [documentazione di DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.NamingRulesDataTypes.html).

# Sistema di tipi (mappatura delle risposte)
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-responses"></a>

Quando riceve una risposta da DynamoDB AWS AppSync , la converte automaticamente in tipi primitivi GraphQL e JSON. Ogni attributo in DynamoDB viene decodificato e restituito nel contesto di mappatura delle risposte.

Ad esempio, se DynamoDB restituisce quanto segue:

```
{
    "id" : { "S" : "1234" },
    "name" : { "S" : "Nadia" },
    "age" : { "N" : 25 }
}
```

Quindi il resolver AWS AppSync DynamoDB lo converte nei tipi GraphQL e JSON come:

```
{
    "id" : "1234",
    "name" : "Nadia",
    "age" : 25
}
```

Questa sezione spiega come AWS AppSync convertire i seguenti tipi di scalari, documenti e set di DynamoDB:

**`S` (tipo String) **  
Un singolo valore di stringa. Un valore DynamoDB String viene restituito come stringa.  
Ad esempio, se DynamoDB ha restituito il seguente valore DynamoDB String:  

```
{ "S" : "some string" }
```
AWS AppSync lo converte in una stringa:  

```
"some string"
```

**`SS` (tipo String set) **  
Un set di valori di stringa. Un valore DynamoDB String Set viene restituito come elenco di stringhe.  
Ad esempio, se DynamoDB ha restituito il seguente valore DynamoDB String Set:  

```
{ "SS" : [ "first value", "second value", ... ] }
```
AWS AppSync lo converte in un elenco di stringhe:  

```
[ "+1 555 123 4567", "+1 555 234 5678" ]
```

**`N` (tipo Number) **  
Un singolo valore numerico. Un valore numerico di DynamoDB viene restituito come numero.  
Ad esempio, se DynamoDB ha restituito il seguente valore numerico di DynamoDB:  

```
{ "N" : 1234 }
```
AWS AppSync lo converte in un numero:  

```
1234
```

**`NS` (tipo Number set) **  
Un set di valori numerici. Un valore del set di numeri di DynamoDB viene restituito come elenco di numeri.  
Ad esempio, se DynamoDB ha restituito il seguente valore del DynamoDB Number Set:  

```
{ "NS" : [ 67.8, 12.2, 70 ] }
```
AWS AppSync lo converte in un elenco di numeri:  

```
[ 67.8, 12.2, 70 ]
```

**`B` (tipo Binary) **  
Un valore binario. Un valore binario di DynamoDB viene restituito come stringa contenente la rappresentazione in base64 di quel valore.  
Ad esempio, se DynamoDB ha restituito il seguente valore binario di DynamoDB:  

```
{ "B" : "SGVsbG8sIFdvcmxkIQo=" }
```
AWS AppSync lo converte in una stringa contenente la rappresentazione in base64 del valore:  

```
"SGVsbG8sIFdvcmxkIQo="
```
I dati binari vengono codificati nello schema di codifica base64 secondo quanto specificato negli standard [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).

**`BS` (tipo Binary set) **  
Un set di valori binari. Un valore del set binario di DynamoDB viene restituito come elenco di stringhe contenenti la rappresentazione in base64 dei valori.  
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB Binary Set:  

```
{ "BS" : [ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ] }
```
AWS AppSync lo converte in un elenco di stringhe contenenti la rappresentazione in base64 dei valori:  

```
[ "SGVsbG8sIFdvcmxkIQo=", "SG93IGFyZSB5b3U/Cg==" ... ]
```
I dati binari vengono codificati nello schema di codifica base64 secondo quanto specificato negli standard [RFC 4648](https://tools.ietf.org/html/rfc4648) e [RFC 2045](https://tools.ietf.org/html/rfc2045).

**`BOOL` (tipo Boolean) **  
Un valore booleano. Un valore booleano DynamoDB viene restituito come booleano.  
Ad esempio, se DynamoDB ha restituito il seguente valore booleano di DynamoDB:  

```
{ "BOOL" : true }
```
AWS AppSync lo converte in booleano:  

```
true
```

**`L` (tipo List) **  
Un elenco di qualsiasi altro valore DynamoDB supportato. Un valore DynamoDB List viene restituito come elenco di valori, in cui viene convertito anche ogni valore interno.  
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB List:  

```
{ "L" : [
      { "S"  : "A string value" },
      { "N"  : 1 },
      { "SS" : [ "Another string value", "Even more string values!" ] }
   ]
}
```
AWS AppSync lo converte in un elenco di valori convertiti:  

```
[ "A string value", 1, [ "Another string value", "Even more string values!" ] ]
```

**`M` (tipo Map) **  
Una key/value raccolta di qualsiasi altro valore DynamoDB supportato. Un valore della mappa DynamoDB viene restituito come oggetto JSON, dove key/value ogni valore viene anche convertito.  
Ad esempio, se DynamoDB ha restituito il seguente valore di DynamoDB Map:  

```
{ "M" : {
      "someString" : { "S"  : "A string value" },
      "someNumber" : { "N"  : 1 },
      "stringSet"  : { "SS" : [ "Another string value", "Even more string values!" ] }
   }
}
```
AWS AppSync lo converte in un oggetto JSON:  

```
{
   "someString" : "A string value",
   "someNumber" : 1,
   "stringSet"  : [ "Another string value", "Even more string values!" ]
}
```

**`NULL` (tipo Null) **  
Un valore nullo.  
Ad esempio, se DynamoDB ha restituito il seguente valore Null di DynamoDB:  

```
{ "NULL" : null }
```
AWS AppSync lo converte in un valore nullo:  

```
null
```

# Filtri
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-filter"></a>

Quando si eseguono interrogazioni su oggetti in DynamoDB utilizzando `Query` le operazioni `Scan` and, è possibile facoltativamente specificare `filter` un valore che valuti i risultati e restituisca solo i valori desiderati.

La sezione di mappatura dei filtri di un documento di mappatura di `Query` o `Scan` ha la seguente struttura:

```
"filter" : {
    "expression" : "filter expression"
    "expressionNames" : {
        "#name" : "name",
    },
    "expressionValues" : {
        ":value" : ... typed value
    },
}
```

I campi sono definiti come segue:

** `expression` **  
L'espressione della query. Per ulteriori informazioni su come scrivere espressioni di filtro, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.QueryFilter.html) [e QueryFilter ScanFilter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/LegacyConditionalParameters.ScanFilter.html) DynamoDB. Questo campo deve essere specificato.

** `expressionNames` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *name* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto nome utilizzato in `expression`. Il valore deve essere una stringa che corrisponde al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in `expression`.

** `expressionValues` **  
Le sostituzioni per i segnaposto dell'attributo di espressione *value* sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato in `expression`, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta [Sistema di tipi (mappatura della richiesta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate in `expression`.

## Esempio
<a name="id18"></a>

L'esempio seguente è una sezione filtro per un modello di mappatura, in cui le voci recuperate da DynamoDB vengono restituite solo se il titolo inizia con l'argomento. `title`

```
"filter" : {
    "expression" : "begins_with(#title, :title)",
    "expressionNames" : {
        "#title" : "title"
    },
    "expressionValues" : {
        ":title" : $util.dynamodb.toDynamoDBJson($context.arguments.title)
    }
}
```

# Espressioni di condizione
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-expressions"></a>

Quando modificate gli oggetti in DynamoDB utilizzando le operazioni`PutItem`, e `DeleteItem` DynamoDB`UpdateItem`, potete facoltativamente specificare un'espressione di condizione che controlli se la richiesta deve avere successo o meno, in base allo stato dell'oggetto già in DynamoDB prima dell'esecuzione dell'operazione.

Il AWS AppSync resolver DynamoDB consente di specificare `PutItem` un'espressione di condizione `DeleteItem` e richiedere documenti di mappatura`UpdateItem`, nonché una strategia da seguire se la condizione fallisce e l'oggetto non è stato aggiornato.

## Esempio 1
<a name="id19"></a>

Il seguente documento di mappatura `PutItem` non contiene un'espressione di condizione. Di conseguenza, inserisce un elemento in DynamoDB anche se esiste già un elemento con la stessa chiave, sovrascrivendo così l'elemento esistente.

```
{
   "version" : "2017-02-28",
   "operation" : "PutItem",
   "key" : {
      "id" : { "S" : "1" }
   }
}
```

## Esempio 2
<a name="id20"></a>

Il seguente documento di `PutItem` mappatura contiene un'espressione di condizione che consente il successo dell'operazione solo se un elemento con la stessa chiave *non* esiste in DynamoDB.

```
{
   "version" : "2017-02-28",
   "operation" : "PutItem",
   "key" : {
      "id" : { "S" : "1" }
   },
   "condition" : {
      "expression" : "attribute_not_exists(id)"
   }
}
```

Per impostazione predefinita, se il controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione. Tuttavia, il AWS AppSync resolver DynamoDB offre alcune funzionalità aggiuntive per aiutare gli sviluppatori a gestire alcuni casi limite comuni:
+ Se AWS AppSync il resolver DynamoDB è in grado di determinare che il valore corrente in DynamoDB corrisponde al risultato desiderato, considera l'operazione come se fosse riuscita comunque.
+ Invece di restituire un errore, puoi configurare il resolver per richiamare una funzione Lambda personalizzata per decidere come il resolver DynamoDB deve gestire AWS AppSync l'errore.

Queste vengono descritte in dettaglio nella sezione [Gestione di un errore nel controllo della condizione](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).

[Per ulteriori informazioni sulle espressioni delle condizioni di DynamoDB, consulta la documentazione di DynamoDB. ConditionExpressions ](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html)

## Specificare una condizione
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-specification"></a>

I documenti di mappatura della richiesta `PutItem`, `UpdateItem` e `DeleteItem` consentono tutti di specificare una sezione facoltativa `condition`. Se omessa, non vengono eseguiti controlli di condizione. Se specificata, la condizione deve essere soddisfatta perché l'operazione abbia esito positivo.

Una sezione `condition` ha la seguente struttura:

```
"condition" : {
    "expression" : "someExpression"
    "expressionNames" : {
        "#foo" : "foo"
    },
    "expressionValues" : {
        ":bar" : ... typed value
    },
    "equalsIgnore" : [ "version" ],
    "consistentRead" : true,
    "conditionalCheckFailedHandler" : {
        "strategy" : "Custom",
        "lambdaArn" : "arn:..."
    }
}
```

I seguenti campi specificano la condizione:

** `expression` **  
L'espressione di aggiornamento in sé. Per ulteriori informazioni su come scrivere espressioni di condizione, consulta la documentazione di [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Questo campo deve essere specificato.

** `expressionNames` **  
Le sostituzioni per i segnaposto dell'attributo di espressione name, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato nell'*espressione* e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in*expression*.

** `expressionValues` **  
Le sostituzioni per i segnaposto del valore dell'attributo di espressione, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato nell'espressione, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta [Sistema di tipi (mappatura della richiesta)](aws-appsync-resolver-mapping-template-reference-dynamodb-typed-values-request.md). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate nell'espressione.

I campi rimanenti indicano al resolver AWS AppSync DynamoDB come gestire un errore di controllo delle condizioni:

** `equalsIgnore` **  
Quando un controllo delle condizioni fallisce durante l'utilizzo dell'`PutItem`operazione, il resolver AWS AppSync DynamoDB confronta l'elemento attualmente in DynamoDB con l'elemento che ha cercato di scrivere. Se sono uguali, tratta l'operazione come se avesse avuto comunque esito positivo. È possibile utilizzare il `equalsIgnore` campo per specificare un elenco di attributi da ignorare quando si esegue il AWS AppSync confronto. Ad esempio, se l'unica differenza era un `version` attributo, considera l'operazione come se fosse riuscita. Questo campo è facoltativo.

** `consistentRead` **  
Quando un controllo delle condizioni fallisce, AWS AppSync ottiene il valore corrente dell'elemento da DynamoDB utilizzando una lettura fortemente coerente. È possibile utilizzare questo campo per indicare al resolver AWS AppSync DynamoDB di utilizzare invece una lettura alla fine coerente. Si tratta di un campo facoltativo, impostato di default su `true`.

** `conditionalCheckFailedHandler` **  
Questa sezione consente di specificare in che modo il resolver AWS AppSync DynamoDB tratta un errore di controllo delle condizioni dopo aver confrontato il valore corrente in DynamoDB con il risultato previsto. Questa sezione è facoltativa. Se omesso, la strategia predefinita è `Reject`.    
** `strategy` **  
La strategia adottata dal AWS AppSync resolver DynamoDB dopo aver confrontato il valore corrente in DynamoDB con il risultato previsto. Questo campo è obbligatorio e ha i seguenti possibili valori:    
** `Reject` **  
La mutazione fallisce e viene aggiunto un errore alla risposta GraphQL.  
** `Custom` **  
Il AWS AppSync resolver DynamoDB richiama una funzione Lambda personalizzata per decidere come gestire l'errore del controllo delle condizioni. Se `strategy` è impostato su `Custom`, il campo `lambdaArn` deve contenere l'ARN della funzione Lambda da invocare.  
** `lambdaArn` **  
L'ARN della funzione Lambda da richiamare che determina in che modo il resolver DynamoDB deve gestire l'errore del controllo delle AWS AppSync condizioni. Questo campo deve essere specificato solo se `strategy` è impostato su `Custom`. Per ulteriori informazioni su come utilizzare questa funzionalità, consulta [Gestione di un errore nel controllo della condizione](#aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling).

## Gestione di un errore di controllo delle condizioni
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-condition-handling"></a>

Per impostazione predefinita, quando un controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB. Tuttavia, il AWS AppSync resolver DynamoDB offre alcune funzionalità aggiuntive per aiutare gli sviluppatori a gestire alcuni casi limite comuni:
+ Se AWS AppSync il resolver DynamoDB è in grado di determinare che il valore corrente in DynamoDB corrisponde al risultato desiderato, considera l'operazione come se fosse riuscita comunque.
+ Invece di restituire un errore, puoi configurare il resolver per richiamare una funzione Lambda personalizzata per decidere come il resolver DynamoDB deve gestire AWS AppSync l'errore.

Il diagramma di questo processo è il seguente:

![\[Flowchart showing process for transforming requests with mutation attempts and value checks.\]](http://docs.aws.amazon.com/it_it/appsync/latest/devguide/images/DynamoDB-condition-check-failure-handling.png)


### Verifica del risultato desiderato
<a name="checking-for-the-desired-result"></a>

Quando il controllo delle condizioni fallisce, il resolver AWS AppSync DynamoDB esegue `GetItem` una richiesta DynamoDB per ottenere il valore corrente dell'elemento da DynamoDB. Per impostazione predefinita, si utilizza una lettura fortemente consistente, ma è possibile intervenire sulla configurazione utilizzando il campo `consistentRead` del blocco `condition` e confrontandolo con il risultato previsto:
+ Per l'`PutItem`operazione, il AWS AppSync resolver DynamoDB confronta il valore corrente con quello che ha tentato di scrivere, escludendo dal confronto tutti gli attributi elencati. `equalsIgnore` Se gli elementi sono uguali, considera l'operazione come riuscita e restituisce l'elemento recuperato da DynamoDB. In caso contrario, viene seguita la strategia configurata.

  Ad esempio, se il documento di mappatura della richiesta `PutItem` fosse simile al seguente:

  ```
  {
     "version" : "2017-02-28",
     "operation" : "PutItem",
     "key" : {
        "id" : { "S" : "1" }
     },
     "attributeValues" : {
        "name" : { "S" : "Steve" },
        "version" : { "N" : 2 }
     },
     "condition" : {
        "expression" : "version = :expectedVersion",
        "expressionValues" : {
            ":expectedVersion" : { "N" : 1 }
        },
        "equalsIgnore": [ "version" ]
     }
  }
  ```

  E la voce attualmente inclusa in DynamoDB fosse simile alla seguente:

  ```
  {
     "id" : { "S" : "1" },
     "name" : { "S" : "Steve" },
     "version" : { "N" : 8 }
  }
  ```

  Il AWS AppSync resolver DynamoDB confronta l'elemento che ha cercato di scrivere con il valore corrente, verifica che l'unica differenza è `version` il campo, ma poiché è configurato per ignorare il campo, considera `version` l'operazione come riuscita e restituisce l'elemento recuperato da DynamoDB.
+ Per l'`DeleteItem`operazione, il resolver AWS AppSync DynamoDB verifica che un elemento sia stato restituito da DynamoDB. Se nessuna voce è stata restituita, considera l'operazione riuscita. In caso contrario, viene seguita la strategia configurata.
+ Per l'`UpdateItem`operazione, il AWS AppSync resolver DynamoDB non dispone di informazioni sufficienti per determinare se l'elemento attualmente in DynamoDB corrisponde al risultato previsto e pertanto segue la strategia configurata.

Se lo stato corrente dell'oggetto in DynamoDB è diverso dal risultato previsto, il resolver AWS AppSync DynamoDB segue la strategia configurata, rifiutando la mutazione o richiamando una funzione Lambda per determinare cosa fare dopo.

### Seguendo la strategia di «rifiuto»
<a name="following-the-reject-strategy"></a>

Quando si segue la `Reject` strategia, il resolver AWS AppSync DynamoDB restituisce un errore per la mutazione.

Ad esempio, partendo dalla richiesta di mutazione seguente:

```
mutation {
    updatePerson(id: 1, name: "Steve", expectedVersion: 1) {
        Name
        theVersion
    }
}
```

Se l'elemento restituito da DynamoDB è simile al seguente:

```
{
   "id" : { "S" : "1" },
   "name" : { "S" : "Steve" },
   "version" : { "N" : 8 }
}
```

E il modello di mappatura della risposta fosse simile al seguente:

```
{
   "id" : $util.toJson($context.result.id),
   "Name" : $util.toJson($context.result.name),
   "theVersion" : $util.toJson($context.result.version)
}
```

La risposta GraphQL ha il seguente aspetto:

```
{
  "data": null,
  "errors": [
    {
      "message": "The conditional request failed (Service: AmazonDynamoDBv2; Status Code: 400; Error Code: ConditionalCheckFailedException; Request ID: ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ)"
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      ...
    }
  ]
}
```

Inoltre, se i campi dell'oggetto restituito sono compilati da altri resolver in caso di successo della mutazione, tali campi non saranno risolti quando l'oggetto viene restituito nella sezione `error`.

### Seguendo la strategia «personalizzata»
<a name="following-the-custom-strategy"></a>

Quando segue la `Custom` strategia, il resolver AWS AppSync DynamoDB richiama una funzione Lambda per decidere cosa fare dopo. La funzione Lambda sceglie una delle seguenti opzioni:
+  Rifiuto della mutazione (`reject`). Ciò indica al AWS AppSync resolver DynamoDB di comportarsi come se lo `Reject` fosse la strategia configurata, restituendo un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB come descritto nella sezione precedente.
+  Rifiuto della mutazione (`discard`). Ciò indica al resolver AWS AppSync DynamoDB di ignorare silenziosamente l'errore del controllo delle condizioni e restituisce il valore in DynamoDB.
+  Rifiuto della mutazione (`retry`). Questo indica al resolver AWS AppSync DynamoDB di riprovare la mutazione con un nuovo documento di mappatura delle richieste.

 **La richiesta di invocazione Lambda** 

Il AWS AppSync resolver DynamoDB richiama la funzione Lambda specificata in. `lambdaArn` Utilizza lo stesso `service-role-arn` configurato per l'origine dati. Il payload dell'invocazione ha la seguente struttura:

```
{
    "arguments": { ... },
    "requestMapping": {... },
    "currentValue": { ... },
    "resolver": { ... },
    "identity": { ... }
}
```

I campi sono definiti come segue:

** `arguments` **  
Gli argomenti della mutazione GraphQL. Sono uguali agli argomenti disponibili per il documento di mappatura della richiesta in `$context.arguments`.

** `requestMapping` **  
Il documento di mappatura della richiesta per questa operazione.

** `currentValue` **  
Il valore corrente dell'oggetto in DynamoDB.

** `resolver` **  
Informazioni sul resolver. AWS AppSync 

** `identity` **  
Informazioni sul chiamante. Sono uguali alle informazioni sull'identità disponibili per il documento di mappatura della richiesta in `$context.identity`.

Un esempio completo di payload:

```
{
    "arguments": {
        "id": "1",
        "name": "Steve",
        "expectedVersion": 1
    },
    "requestMapping": {
        "version" : "2017-02-28",
        "operation" : "PutItem",
        "key" : {
           "id" : { "S" : "1" }
        },
        "attributeValues" : {
           "name" : { "S" : "Steve" },
           "version" : { "N" : 2 }
        },
        "condition" : {
           "expression" : "version = :expectedVersion",
           "expressionValues" : {
               ":expectedVersion" : { "N" : 1 }
           },
           "equalsIgnore": [ "version" ]
        }
    },
    "currentValue": {
        "id" : { "S" : "1" },
        "name" : { "S" : "Steve" },
        "version" : { "N" : 8 }
    },
    "resolver": {
        "tableName": "People",
        "awsRegion": "us-west-2",
        "parentType": "Mutation",
        "field": "updatePerson",
        "outputType": "Person"
    },
    "identity": {
        "accountId": "123456789012",
        "sourceIp": "x.x.x.x",
        "user": "AIDAAAAAAAAAAAAAAAAAA",
        "userArn": "arn:aws:iam::123456789012:user/appsync"
    }
}
```

 **La risposta all'invocazione Lambda** 

La funzione Lambda può ispezionare il payload di chiamata e applicare qualsiasi logica aziendale per decidere come il resolver DynamoDB deve gestire l'errore AWS AppSync . Sono disponibili tre opzioni per la gestione dell'errore nel controllo della condizione:
+  Rifiuto della mutazione (`reject`). Il payload di risposta per questa opzione deve avere questa struttura:

  ```
  {
      "action": "reject"
  }
  ```

  Ciò indica al AWS AppSync resolver DynamoDB di comportarsi come se la strategia configurata lo `Reject` fosse, restituendo un errore per la mutazione e il valore corrente dell'oggetto in DynamoDB, come descritto nella sezione precedente.
+  Rifiuto della mutazione (`discard`). Il payload di risposta per questa opzione deve avere questa struttura:

  ```
  {
      "action": "discard"
  }
  ```

  Ciò indica al resolver AWS AppSync DynamoDB di ignorare silenziosamente l'errore del controllo delle condizioni e restituisce il valore in DynamoDB.
+  Rifiuto della mutazione (`retry`). Il payload di risposta per questa opzione deve avere questa struttura:

  ```
  {
      "action": "retry",
      "retryMapping": { ... }
  }
  ```

  Questo indica al resolver AWS AppSync DynamoDB di riprovare la mutazione con un nuovo documento di mappatura delle richieste. La struttura della `retryMapping` sezione dipende dall'operazione DynamoDB ed è un sottoinsieme del documento completo di mappatura delle richieste per quell'operazione.

  Per `PutItem`, la sezione `retryMapping` ha la seguente struttura. Per una descrizione del campo, vedere. `attributeValues` [PutItem](aws-appsync-resolver-mapping-template-reference-dynamodb-putitem.md)

  ```
  {
      "attributeValues": { ... },
      "condition": {
          "equalsIgnore" = [ ... ],
          "consistentRead" = true
      }
  }
  ```

  Per `UpdateItem`, la sezione `retryMapping` ha la seguente struttura. Per una descrizione della `update` sezione, vedere [UpdateItem](aws-appsync-resolver-mapping-template-reference-dynamodb-updateitem.md).

  ```
  {
      "update" : {
          "expression" : "someExpression"
          "expressionNames" : {
              "#foo" : "foo"
          },
          "expressionValues" : {
              ":bar" : ... typed value
          }
      },
      "condition": {
          "consistentRead" = true
      }
  }
  ```

  Per `DeleteItem`, la sezione `retryMapping` ha la seguente struttura.

  ```
  {
      "condition": {
          "consistentRead" = true
      }
  }
  ```

  Non c'è modo di specificare operazioni o chiavi diverse su cui lavorare. Il AWS AppSync resolver DynamoDB consente solo di ripetere la stessa operazione sullo stesso oggetto. Inoltre, la sezione `condition` non consente di specificare un valore per `conditionalCheckFailedHandler`. Se il nuovo tentativo fallisce, il resolver AWS AppSync DynamoDB segue la strategia. `Reject`

Ecco un esempio di funzione Lambda per far fronte a una richiesta `PutItem` non riuscita. La logica di business osserva l'autore della chiamata. Se è stata effettuata da`jeffTheAdmin`, riprova la richiesta, aggiornando l'`version`and `expectedVersion` dall'elemento attualmente in DynamoDB. Altrimenti rifiuta la mutazione.

```
exports.handler = (event, context, callback) => {
    console.log("Event: "+ JSON.stringify(event));

    // Business logic goes here.

    var response;
    if ( event.identity.user == "jeffTheAdmin" ) {
        response = {
            "action" : "retry",
            "retryMapping" : {
                "attributeValues" : event.requestMapping.attributeValues,
                "condition" : {
                    "expression" : event.requestMapping.condition.expression,
                    "expressionValues" : event.requestMapping.condition.expressionValues
                }
            }
        }
        response.retryMapping.attributeValues.version = { "N" : event.currentValue.version.N + 1 }
        response.retryMapping.condition.expressionValues[':expectedVersion'] = event.currentValue.version

    } else {
        response = { "action" : "reject" }
    }

    console.log("Response: "+ JSON.stringify(response))
    callback(null, response)
};
```

# Espressioni relative alle condizioni delle transazioni
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-transaction-condition-expressions"></a>

Le espressioni di condizione delle transazioni sono disponibili nei modelli di mappatura delle richieste di tutti e quattro i tipi di operazioni in `TransactWriteItems`, vale a dire `PutItem`, `DeleteItem`, `UpdateItem` e `ConditionCheck`.

Per`PutItem`, e `DeleteItem``UpdateItem`, l'espressione della condizione di transazione è facoltativa. Perché`ConditionCheck`, l'espressione della condizione della transazione è obbligatoria.

## Esempio 1
<a name="id22"></a>

Il seguente documento di mappatura `DeleteItem` transazionale non dispone di un'espressione di condizione. Di conseguenza, elimina l'elemento in DynamoDB.

```
{
   "version": "2018-05-29",
   "operation": "TransactWriteItems",
   "transactItems": [
      {
         "table": "posts",
         "operation": "DeleteItem",
         "key": {
            "id": { "S" : "1" }
         }
      }
   ]
}
```

## Esempio 2
<a name="id23"></a>

Il seguente documento di `DeleteItem` mappatura transazionale contiene un'espressione della condizione di transazione che consente l'esito positivo dell'operazione solo se l'autore di quel post è uguale a un determinato nome.

```
{
   "version": "2018-05-29",
   "operation": "TransactWriteItems",
   "transactItems": [
      {
         "table": "posts",
         "operation": "DeleteItem",
         "key": {
            "id": { "S" : "1" }
         }
         "condition": {
            "expression": "author = :author",
            "expressionValues": {
               ":author": { "S" : "Chunyan" }
            }
         }
      }
   ]
}
```

Se il controllo della condizione fallisce, genera una `TransactionCanceledException` e il dettaglio dell'errore viene restituito in `$ctx.result.cancellationReasons`. Tieni presente che, per impostazione predefinita, verrà restituito il vecchio elemento in DynamoDB che ha impedito il controllo delle condizioni. `$ctx.result.cancellationReasons`

## Specificare una condizione
<a name="id24"></a>

I documenti di mappatura della richiesta `PutItem`, `UpdateItem` e `DeleteItem` consentono tutti di specificare una sezione facoltativa `condition`. Se omessa, non vengono eseguiti controlli di condizione. Se specificata, la condizione deve essere soddisfatta perché l'operazione abbia esito positivo. Per `ConditionCheck` deve essere specificata una sezione `condition`. La condizione deve essere vera affinché l'intera transazione abbia esito positivo.

Una sezione `condition` ha la seguente struttura:

```
"condition": {
    "expression": "someExpression",
    "expressionNames": {
        "#foo": "foo"
    },
    "expressionValues": {
        ":bar": ... typed value
    },
    "returnValuesOnConditionCheckFailure": false
}
```

I seguenti campi specificano la condizione:

** `expression` **  
L'espressione di aggiornamento in sé. Per ulteriori informazioni su come scrivere espressioni di condizione, consulta la documentazione di [ ConditionExpressions DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ConditionExpressions.html). Questo campo deve essere specificato.

** `expressionNames` **  
Le sostituzioni per i segnaposto dell'attributo di espressione name, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per il nome utilizzato nell'*espressione* e il valore deve essere una stringa corrispondente al nome dell'attributo dell'elemento in DynamoDB. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione name utilizzate in*expression*.

** `expressionValues` **  
Le sostituzioni per i segnaposto del valore dell'attributo di espressione, sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto per un valore utilizzato nell'espressione, mentre il valore deve essere un valore tipizzato. Per ulteriori informazioni su come specificare un "valore tipizzato", consulta Sistema di tipi (mappatura della richiesta). Questo elemento deve essere specificato. Questo è un campo facoltativo in cui vanno riportate solo le sostituzioni per i segnaposto dell'attributo di espressione value utilizzate nell'espressione.

** `returnValuesOnConditionCheckFailure` **  
Specificare se recuperare l'elemento in DynamoDB quando un controllo delle condizioni fallisce. L'elemento recuperato sarà in `$ctx.result.cancellationReasons[$index].item`, dove `$index` è l'indice dell'elemento richiesta che non ha superato il controllo della condizione. Il valore predefinito di questo valore è true.

# Proiezioni
<a name="aws-appsync-resolver-mapping-template-reference-dynamodb-projections"></a>

Quando si leggono oggetti in DynamoDB utilizzando `GetItem` le operazioni`Scan`,, `Query``BatchGetItem`, `TransactGetItems` e,, è possibile specificare facoltativamente una proiezione che identifichi gli attributi desiderati. La proiezione ha la seguente struttura, simile ai filtri: 

```
"projection" : {
    "expression" : "projection expression"
    "expressionNames" : {
        "#name" : "name",
    }
}
```

I campi sono definiti come segue:

**`expression`**   
L'espressione di proiezione, che è una stringa. Per recuperare un singolo attributo, specificane il nome. Per più attributi, i nomi devono essere valori separati da virgole. Per ulteriori informazioni sulla scrittura di espressioni di proiezione, consulta la documentazione delle espressioni di proiezione [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ProjectionExpressions.html). Questo campo è obbligatorio. 

 **`expressionNames`**   
Le sostituzioni degli attributi di espressione *chiamano* segnaposto sotto forma di coppie chiave-valore. La chiave corrisponde a un segnaposto nome utilizzato in `expression`. Il valore deve essere una stringa che corrisponde al nome dell'attributo dell'elemento in DynamoDB. Questo campo è facoltativo e deve essere compilato solo con sostituzioni per i segnaposto dei nomi degli attributi di espressione utilizzati in. `expression` Per ulteriori informazioni`expressionNames`, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Expressions.ExpressionAttributeNames.html). 

## Esempio 1
<a name="id25"></a>

L'esempio seguente è una sezione di proiezione per un modello di mappatura VTL in cui `id` vengono restituiti solo gli attributi `author` e da DynamoDB:

```
"projection" : {
    "expression" : "#author, id",
    "expressionNames" : {
        "#author" : "author"
    }
}
```

**Suggerimento**  
[È possibile accedere al set di selezione delle richieste GraphQL utilizzando \$1context.info. selectionSetList](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference.html#aws-appsync-resolver-context-reference-info). Questo campo consente di inquadrare l'espressione di proiezione in modo dinamico in base alle proprie esigenze.

**Nota**  
Quando si utilizzano espressioni di proiezione con le `Scan` operazioni `Query` and, il valore per `select` deve essere. `SPECIFIC_ATTRIBUTES` Per ulteriori informazioni, consulta la documentazione di [DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_Query.html#DDB-Query-request-Select).

# AWS AppSync riferimento al modello di mappatura del resolver per RDS
<a name="resolver-mapping-template-reference-rds"></a>

I modelli di mappatura AWS AppSync dei resolver RDS consentono agli sviluppatori di inviare query SQL a un'API di dati per Amazon Aurora Serverless e ottenere il risultato di queste query.

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

Il modello di mappatura della richiesta per RDS è abbastanza semplice:

```
{
    "version": "2018-05-29",
    "statements": [],
    "variableMap": {},
    "variableTypeHintMap": {}
}
```

Di seguito è riportata la rappresentazione dello schema JSON del modello di mappatura della richiesta RDS, dopo la risoluzione.

```
{
    "definitions": {},
    "$schema": "https://json-schema.org/draft-07/schema#",
    "$id": "https://example.com/root.json",
    "type": "object",
    "title": "The Root Schema",
    "required": [
        "version",
        "statements",
        "variableMap"
    ],
    "properties": {
        "version": {
            "$id": "#/properties/version",
            "type": "string",
            "title": "The Version Schema",
            "default": "",
            "examples": [
                "2018-05-29"
            ],
            "enum": [
                "2018-05-29"
            ],
            "pattern": "^(.*)$"
        },
        "statements": {
            "$id": "#/properties/statements",
            "type": "array",
            "title": "The Statements Schema",
            "items": {
                "$id": "#/properties/statements/items",
                "type": "string",
                "title": "The Items Schema",
                "default": "",
                "examples": [
                    "SELECT * from BOOKS"
                ],
                "pattern": "^(.*)$"
            }
        },
        "variableMap": {
            "$id": "#/properties/variableMap",
            "type": "object",
            "title": "The Variablemap Schema"
        },
        "variableTypeHintMap": {
            "$id": "#/properties/variableTypeHintMap",
            "type": "object",
            "title": "The variableTypeHintMap Schema"
        }
    }
}
```

Di seguito è riportato un esempio del modello di mappatura delle richieste con una query statica:

```
{
    "version": "2018-05-29",
    "statements": [
        "select title, isbn13 from BOOKS where author = 'Mark Twain'"
    ]
}
```

## Versione
<a name="version"></a>

Comune a tutti i modelli di mappatura delle richieste, il campo della versione definisce la versione utilizzata dal modello. Il campo della versione è obbligatorio. Il valore «2018-05-29" è l'unica versione supportata per i modelli di mappatura Amazon RDS.

```
"version": "2018-05-29"
```

## Dichiarazioni e VariableMap
<a name="statements-variablemap"></a>

L'array statements è un segnaposto per le query fornite dallo sviluppatore. Attualmente sono supportate fino a due query per modello di mappatura delle richieste. `variableMap`È un campo facoltativo che contiene alias che possono essere utilizzati per rendere le istruzioni SQL più brevi e più leggibili. Ad esempio, è possibile quanto segue:

```
{
"version": "2018-05-29",
    "statements": [
        "insert into BOOKS VALUES (:AUTHOR, :TITLE, :ISBN13)",
        "select * from BOOKS WHERE isbn13 = :ISBN13"
    ],
    "variableMap": {
        ":AUTHOR": $util.toJson($ctx.args.newBook.author),
        ":TITLE": $util.toJson($ctx.args.newBook.title),
        ":ISBN13": $util.toJson($ctx.args.newBook.isbn13)
    }
}
```

AWS AppSync utilizzerà i valori delle mappe variabili per creare le **[SqlParameterized](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html)**query che verranno inviate all'API Amazon Aurora Serverless Data. Le istruzioni SQL vengono eseguite con i parametri forniti nella mappa variabile, il che elimina il rischio di iniezione SQL. 

## VariableTypeHintMap
<a name="variabletypehintmap"></a>

`variableTypeHintMap`È un campo opzionale contenente tipi di alias che possono essere utilizzati per inviare suggerimenti sui tipi di [parametri SQL](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html). Questi suggerimenti di tipo evitano l'inserimento esplicito nelle istruzioni SQL, rendendole più brevi. Ad esempio, è possibile quanto segue:

```
{
    "version": "2018-05-29",
    "statements": [
        "insert into LOGINDATA VALUES (:ID, :TIME)",
        "select * from LOGINDATA WHERE id = :ID"
     ],
     "variableMap": {
        ":ID": $util.toJson($ctx.args.id),
        ":TIME": $util.toJson($ctx.args.time)
     },
     "variableTypeHintMap": {
        ":id": "UUID",
        ":time": "TIME"
     }
}
```

AWS AppSync utilizzerà il valore della mappa variabile per creare le query inviate all'API Amazon Aurora Serverless Data. Inoltre utilizza i `variableTypeHintMap` dati e invia le informazioni del tipo a RDS. [La versione supportata da RDS `typeHints` è disponibile qui.](https://docs.aws.amazon.com/rdsdataservice/latest/APIReference/API_SqlParameter.html)

# AWS AppSync riferimento al modello di mappatura del resolver per OpenSearch
<a name="resolver-mapping-template-reference-elasticsearch"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Il AWS AppSync resolver per Amazon OpenSearch Service ti consente di utilizzare GraphQL per archiviare e recuperare dati nei domini di OpenSearch servizio esistenti nel tuo account. Questo resolver consente di mappare una richiesta GraphQL in OpenSearch entrata in una richiesta di servizio, quindi mappare la risposta OpenSearch del servizio a GraphQL. Questa sezione descrive i modelli di mappatura per le operazioni di servizio supportate. OpenSearch 

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

La maggior parte dei modelli di mappatura delle richieste di OpenSearch assistenza ha una struttura comune in cui cambiano solo pochi elementi. L'esempio seguente esegue una ricerca in un dominio di OpenSearch servizio, in cui i documenti sono organizzati in base a un indice chiamato`post`. I parametri di ricerca sono definiti nella sezione `body`, con molte delle clausole di query comuni definite nel campo `query`. Questo esempio esegue la ricerca di documenti contenenti `"Nadia"`o `"Bailey"`, o entrambe le stringhe, nel campo `author` di un documento:

```
{
    "version":"2017-02-28",
    "operation":"GET",
    "path":"/post/_search",
    "params":{
        "headers":{},
        "queryString":{},
        "body":{
            "from":0,
            "size":50,
            "query" : {
                "bool" : {
                    "should" : [
                        {"match" : { "author" : "Nadia" }},
                        {"match" : { "author" : "Bailey" }}
                    ]
                }
            }
        }
    }
}
```

## Modello di mappatura delle risposte
<a name="response-mapping-template"></a>

Come con altre fonti di dati, OpenSearch Service invia una risposta AWS AppSync che deve essere convertita in GraphQL.

La maggior parte delle query GraphQL cerca il `_source` campo in una OpenSearch risposta del servizio. Poiché è possibile eseguire ricerche per restituire un singolo documento o un elenco di documenti, in Service vengono utilizzati due modelli di mappatura delle risposte comuni: OpenSearch 

 **Elenco di risultati** 

```
[
    #foreach($entry in $context.result.hits.hits)
      #if( $velocityCount > 1 ) , #end
        $utils.toJson($entry.get("_source"))
    #end
]
```

 **Singola voce** 

```
$utils.toJson($context.result.get("_source"))
```

## Campo `operation`
<a name="operation-field"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Metodo o verbo HTTP (GET, POST, PUT, HEAD o DELETE) che AWS AppSync invia al dominio del OpenSearch servizio. Sia la chiave che il valore devono essere stringhe.

```
"operation" : "PUT"
```

## Campo `path`
<a name="path-field"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Il percorso di ricerca per una richiesta OpenSearch di servizio da AWS AppSync. Costituisce un URL per il verbo HTTP dell'operazione. Sia la chiave che il valore devono essere stringhe.

```
"path" : "/<indexname>/_doc/<_id>"
"path" : "/<indexname>/_doc"
"path" : "/<indexname>/_search"
"path" : "/<indexname>/_update/<_id>
```

Quando il modello di mappatura viene valutato, questo percorso viene inviato come parte della richiesta HTTP, incluso il dominio del OpenSearch servizio. L'esempio precedente potrebbe diventare:

```
GET https://opensearch-domain-name.REGION.es.amazonaws.com/indexname/type/_search
```

## Campo `params`
<a name="params-field"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Usato per specificare l'operazione eseguita dalla ricerca, in genere impostando il valore **query** all'interno di **body**. Ci sono tuttavia numerose altre funzionalità che è possibile configurare, ad esempio la formattazione delle risposte.
+  **headers** 

  Informazioni dell'intestazione, come coppie chiave-valore. Sia la chiave che il valore devono essere stringhe. Esempio:

  ```
  "headers" : {
      "Content-Type" : "application/json"
  }
  ```
**Nota**  
AWS AppSync attualmente supporta solo JSON come. `Content-Type`
+  **queryString** 

  Coppie chiave-valore che specificano opzioni comuni, ad esempio la formattazione del codice per le risposte JSON. Sia la chiave che il valore devono essere stringhe. Ad esempio, per ottenere codice JSON con formattazione Pretty, usa:

  ```
  "queryString" : {
      "pretty" : "true"
  }
  ```
+  **body** 

  Questa è la parte principale della richiesta, che consente di AWS AppSync creare una richiesta di ricerca ben formata per il dominio del OpenSearch Servizio. La chiave deve essere una stringa costituita da un oggetto. Di seguito sono illustrati un paio di esempi.

 **Esempio 1** 

Restituisce tutti i documenti in cui la città corrisponde a "seattle":

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "match" : {
            "city" : "seattle"
        }
    }
}
```

 **Esempio 2** 

Restituisce tutti i documenti in cui la città o lo stato corrisponde a "washington":

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "multi_match" : {
            "query" : "washington",
            "fields" : ["city", "state"]
        }
    }
}
```

## Passare variabili
<a name="passing-variables"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

È inoltre possibile passare le variabili come parte della valutazione nell'istruzione VTL. Supponi ad esempio di avere una query GraphQL come la seguente:

```
query {
    searchForState(state: "washington"){
        ...
    }
}
```

Il modello di mappatura può accettare lo stato come argomento:

```
"body":{
    "from":0,
    "size":50,
    "query" : {
        "multi_match" : {
            "query" : "$context.arguments.state",
            "fields" : ["city", "state"]
        }
    }
}
```

Per un elenco di utilità che è possibile includere in VTL, consulta l'argomento relativo all'[accesso alle intestazioni di richiesta](resolver-context-reference.md#aws-appsync-resolver-context-reference-util).

# AWS AppSync riferimento al modello di mappatura del resolver per Lambda
<a name="resolver-mapping-template-reference-lambda"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Puoi usare AWS AppSync funzioni e resolver per richiamare le funzioni Lambda presenti nel tuo account. Puoi modellare i payload della richiesta e la risposta delle tue funzioni Lambda prima di restituirli ai tuoi clienti. Puoi anche utilizzare modelli di mappatura per fornire suggerimenti AWS AppSync sulla natura dell'operazione da richiamare. Questa sezione descrive i diversi modelli di mappatura per le operazioni Lambda supportate.

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

Il modello di mappatura delle richieste Lambda gestisce i campi relativi alla tua funzione Lambda:

```
{
  "version": string,
  "operation": Invoke|BatchInvoke,
  "payload": any type,
  "invocationType": RequestResponse|Event
}
```

Questa è la rappresentazione dello schema JSON del modello di mappatura delle richieste Lambda una volta risolto:

```
{
  "definitions": {},
  "$schema": "https://json-schema.org/draft-06/schema#",
  "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
  "type": "object",
  "properties": {
    "version": {
      "$id": "/properties/version",
      "type": "string",
      "enum": [
        "2018-05-29"
      ],
      "title": "The Mapping template version.",
      "default": "2018-05-29"
    },
    "operation": {
      "$id": "/properties/operation",
      "type": "string",
      "enum": [
        "Invoke",
        "BatchInvoke"
      ],
      "title": "The Mapping template operation.",
      "description": "What operation to execute.",
      "default": "Invoke"
    },
    "payload": {},
    "invocationType": {
      "$id": "/properties/invocationType",
      "type": "string",
      "enum": [
        "RequestResponse",
        "Event"
      ],
      "title": "The Mapping template invocation type.",
      "description": "What invocation type to execute.",
      "default": "RequestResponse"
    }
  },
  "required": [
    "version",
    "operation"
  ],
  "additionalProperties": false
}
```

Ecco un esempio che utilizza un'`invoke`operazione i cui dati di payload sono il `getPost` campo di uno schema GraphQL insieme ai suoi argomenti dal contesto:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": $util.toJson($context.arguments)
  }
}
```

L'intero documento di mappatura viene passato come input alla funzione Lambda in modo che l'esempio precedente abbia ora il seguente aspetto:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "payload": {
    "field": "getPost",
    "arguments": {
      "id": "postId1"
    }
  }
}
```

### Versione
<a name="version"></a>

Comune a tutti i modelli di mappatura delle richieste, `version` definisce la versione utilizzata dal modello. `version`È obbligatorio ed è un valore statico:

```
"version": "2018-05-29"
```

### Operation
<a name="operation"></a>

L'origine dati Lambda consente di definire due operazioni sul `operation` campo: `Invoke` e. `BatchInvoke` L'`Invoke`operazione consente di AWS AppSync sapere di chiamare la funzione Lambda per ogni resolver di campi GraphQL. `BatchInvoke`indica di eseguire AWS AppSync in batch le richieste per il campo GraphQL corrente. Il campo `operation` è obbligatorio.

Infatti`Invoke`, il modello di mappatura delle richieste risolte corrisponde al payload di input della funzione Lambda. Modifichiamo l'esempio precedente:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": $util.toJson($context.arguments)
    }
}
```

Questo problema viene risolto e passato alla funzione Lambda, che potrebbe assomigliare a questa:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
    "payload": {
      "arguments": {
        "id": "postId1"
      }
    }
}
```

Infatti`BatchInvoke`, il modello di mappatura viene applicato a tutti i risolutori di campo del batch. Per motivi di concisione, AWS AppSync unisce tutti i `payload` valori del modello di mappatura risolti in un elenco sotto un singolo oggetto corrispondente al modello di mappatura. Il modello di esempio seguente mostra l'unione:

```
{
  "version": "2018-05-29",
  "operation": "BatchInvoke",
  "payload": $util.toJson($context)
}
```

Questo modello viene risolto nel documento di mappatura seguente:

```
{
  "version": "2018-05-29",
  "operation": "BatchInvoke",
  "payload": [
    {...}, // context for batch item 1
    {...}, // context for batch item 2
    {...}  // context for batch item 3
  ]
}
```

Ogni elemento dell'`payload`elenco corrisponde a un singolo elemento del batch. La funzione Lambda dovrebbe inoltre restituire una risposta a forma di elenco corrispondente all'ordine degli elementi inviati nella richiesta:

```
[
  { "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 1
  { "data": {...}, "errorMessage": null, "errorType": null }, // result for batch item 2
  { "data": {...}, "errorMessage": null, "errorType": null }  // result for batch item 3
]
```

### Carico utile
<a name="payload"></a>

Il `payload` campo è un contenitore utilizzato per passare qualsiasi JSON ben formato alla funzione Lambda. Se il `operation` campo è impostato su`BatchInvoke`, AWS AppSync racchiude i valori esistenti `payload` in un elenco. Il campo `payload` è facoltativo.

### Tipo di invocazione
<a name="async-invocation-type"></a>

L'origine dati Lambda consente di definire due tipi di invocazione: e. `RequestResponse` `Event` [I tipi di invocazione sono sinonimi dei tipi di invocazione definiti nell'API Lambda.](https://docs.aws.amazon.com//lambda/latest/api/API_Invoke.html) Il tipo di `RequestResponse` invocazione consente di AWS AppSync chiamare la funzione Lambda in modo sincrono per attendere una risposta. L'`Event`invocazione consente di richiamare la funzione Lambda in modo asincrono. [Per ulteriori informazioni su come Lambda gestisce le richieste dei tipi di `Event` invocazione, consulta Invocazione asincrona.](https://docs.aws.amazon.com/lambda/latest/dg/invocation-async.html) Il campo `invocationType` è facoltativo. Se questo campo non è incluso nella richiesta, verrà utilizzato per impostazione predefinita il tipo di invocazione. AWS AppSync `RequestResponse`

Per qualsiasi `invocationType` campo, la richiesta risolta corrisponde al payload di input della funzione Lambda. Modifichiamo l'esempio precedente:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "invocationType": "Event"
  "payload": {
    "arguments": $util.toJson($context.arguments)
  }
}
```

Questo problema viene risolto e passato alla funzione Lambda, che potrebbe assomigliare a questa:

```
{
  "version": "2018-05-29",
  "operation": "Invoke",
  "invocationType": "Event",
  "payload": {
    "arguments": {
      "id": "postId1"
    }
  }
}
```

Quando l'`BatchInvoke`operazione viene utilizzata insieme al campo del tipo di `Event` invocazione, AWS AppSync unisce il resolver di campo nello stesso modo menzionato sopra e la richiesta viene passata alla funzione Lambda come evento asincrono costituito da un elenco di valori. `payload` Ti consigliamo di disabilitare la memorizzazione nella cache dei resolver per i resolver di tipo di `Event` invocazione perché questi non verrebbero inviati a Lambda se si verificasse un problema nella cache.

## Modello di mappatura delle risposte
<a name="response-mapping-template"></a>

Come con altre fonti di dati, la funzione Lambda invia una risposta a AWS AppSync che deve essere convertita in un tipo GraphQL.

Il risultato della funzione Lambda viene impostato sull'`context`oggetto disponibile tramite la proprietà Velocity Template Language (VTL). `$context.result`

Se la forma della risposta della funzione Lambda corrisponde esattamente alla forma del tipo GraphQL, puoi inoltrare la risposta usando il modello di mappatura della risposta seguente:

```
$util.toJson($context.result)
```

Non ci sono campi obbligatori né restrizioni relative alla forma che si applicano al modello di mappatura della risposta. Tuttavia, poiché GraphQL è un protocollo fortemente tipizzato, il modello di mappatura risolto deve corrispondere al tipo GraphQL previsto.

## Risposta in batch della funzione Lambda
<a name="aws-appsync-resolver-mapping-template-reference-lambda-batched-response"></a>

Se il campo `operation` è impostato su `BatchInvoke`, AWS AppSync si aspetta che la funzione Lambda restituisca un elenco di voci. Per riportare ogni risultato AWS AppSync all'elemento della richiesta originale, l'elenco delle risposte deve corrispondere per dimensioni e ordine. È valido avere `null` elementi nell'elenco delle risposte; `$ctx.result` è impostato di conseguenza su *null*.

## Resolver Lambda diretti
<a name="direct-lambda-resolvers"></a>

Se desideri aggirare completamente l'uso dei modelli di mappatura, AWS AppSync puoi fornire un payload predefinito alla tua funzione Lambda e una risposta della funzione Lambda predefinita a un tipo GraphQL. Puoi scegliere di fornire un modello di richiesta, un modello di risposta o nessuno dei due e gestirlo di conseguenza. AWS AppSync 

### Modello di mappatura delle richieste Direct Lambda
<a name="lambda-mapping-template-bypass-request"></a>

Quando il modello di mappatura della richiesta non viene fornito, AWS AppSync invierà l'`Context`oggetto direttamente alla funzione Lambda come `Invoke` operazione. Per ulteriori informazioni sulla struttura dell’oggetto `Context`, consulta [AWS AppSync riferimento al contesto del modello di mappatura del resolver](resolver-context-reference.md).

### Modello di mappatura della risposta Direct Lambda
<a name="lambda-mapping-template-bypass-response"></a>

Quando il modello di mappatura delle risposte non viene fornito, AWS AppSync esegue una delle due operazioni dopo aver ricevuto la risposta della funzione Lambda. Se non hai fornito un modello di mappatura delle richieste o se hai fornito un modello di mappatura delle richieste con la versione`2018-05-29`, la risposta sarà equivalente al seguente modello di mappatura delle risposte:

```
#if($ctx.error)
     $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
 #end
 $util.toJson($ctx.result)
```

Se hai fornito un modello con la versione`2017-02-28`, la logica di risposta funziona in modo equivalente al seguente modello di mappatura delle risposte:

```
$util.toJson($ctx.result)
```

Superficialmente, il bypass del modello di mappatura funziona in modo simile all'utilizzo di determinati modelli di mappatura, come mostrato negli esempi precedenti. Tuttavia, dietro le quinte, la valutazione dei modelli di mappatura viene completamente elusa. Poiché la fase di valutazione del modello viene ignorata, in alcuni scenari le applicazioni potrebbero subire un sovraccarico e una latenza inferiori durante la risposta rispetto a una funzione Lambda con un modello di mappatura delle risposte che deve essere valutato. 

### Gestione personalizzata degli errori nelle risposte di Direct Lambda Resolver
<a name="lambda-mapping-template-bypass-errors"></a>

Puoi personalizzare le risposte agli errori delle funzioni Lambda richiamate dai Direct Lambda Resolver sollevando un'eccezione personalizzata. L'esempio seguente mostra come creare un'eccezione personalizzata utilizzando: JavaScript

```
class CustomException extends Error {
  constructor(message) {
    super(message);
    this.name = "CustomException";
  }
}
 
throw new CustomException("Custom message");
```

Quando vengono sollevate eccezioni, i `errorType` e `errorMessage` sono rispettivamente l'errore personalizzato generato `name` e `message` l'errore personalizzato generato.

In caso `errorType` `UnauthorizedException` AWS AppSync affermativo, restituisce il messaggio predefinito (`"You are not authorized to make this call."`) anziché un messaggio personalizzato.

Il seguente frammento è un esempio di risposta GraphQL che dimostra una personalizzazione: `errorType`

```
{
  "data": {
    "query": null
  },
  "errors": [
    {
      "path": [
        "query"
      ],
      "data": null,
      "errorType": "CustomException",
      "errorInfo": null,
      "locations": [
        {
          "line": 5,
          "column": 10,
          "sourceName": null
        }
      ],
      "message": "Custom Message"
    }
  ]
}
```

### Direct Lambda Resolver: batch abilitato
<a name="lambda-resolvers-batching"></a>

Puoi abilitare il batching per il tuo Direct Lambda Resolver `maxBatchSize` configurandolo sul tuo resolver. Quando `maxBatchSize` è impostato su un valore maggiore di quello `0` di un resolver Direct Lambda, AWS AppSync invia richieste in batch alla funzione Lambda con dimensioni fino a. `maxBatchSize` 

L'impostazione `maxBatchSize` `0` su un resolver Direct Lambda disattiva il batch.

Per ulteriori informazioni su come funziona il batching con i resolver Lambda, consulta. [Caso d'uso avanzato: Batching](tutorial-lambda-resolvers.md#advanced-use-case-batching)

#### Richiedi un modello di mappatura
<a name="lambda-resolvers-batching-request-template"></a>

Quando il batching è abilitato e il modello di mappatura della richiesta non viene fornito, AWS AppSync invia un elenco di `Context` oggetti come `BatchInvoke` operazione direttamente alla funzione Lambda.

#### Modello di mappatura delle risposte
<a name="lambda-resolvers-batching-response-template"></a>

Quando il batching è abilitato e il modello di mappatura delle risposte non viene fornito, la logica di risposta è equivalente al seguente modello di mappatura delle risposte:

```
#if( $context.result && $context.result.errorMessage )
      $utils.error($context.result.errorMessage, $context.result.errorType,
      $context.result.data)
#else
      $utils.toJson($context.result.data)
#end
```

La funzione Lambda deve restituire un elenco di risultati nello stesso ordine dell'elenco degli `Context` oggetti inviati. È possibile restituire singoli errori fornendo un `errorMessage` e `errorType` per un risultato specifico. Ogni risultato dell'elenco ha il seguente formato:

```
{
   "data" : { ... }, // your data
   "errorMessage" : { ... }, // optional, if included an error entry is added to the "errors" object in the AppSync response 
   "errorType" : { ... } // optional, the error type
}
```

**Nota**  
Gli altri campi dell'oggetto risultato sono attualmente ignorati.

#### Gestione degli errori da Lambda
<a name="lambda-resolvers-batching-error-handling"></a>

Puoi restituire un errore per tutti i risultati generando un'eccezione o un errore nella tua funzione Lambda. Se la dimensione della richiesta di payload o della risposta per la richiesta batch è troppo grande, Lambda restituisce un errore. In tal caso, dovresti prendere in considerazione la possibilità di ridurre `maxBatchSize` o ridurre le dimensioni del payload di risposta.

Per informazioni sulla gestione dei singoli errori, vedere[Restituzione di errori individuali](tutorial-lambda-resolvers.md#returning-individual-errors).

#### Funzioni Lambda di esempio
<a name="sample-lambda-function"></a>

Utilizzando lo schema seguente, puoi creare un Direct Lambda Resolver per il `Post.relatedPosts` field resolver e abilitare il batching impostando sopra: `maxBatchSize` `0`

```
schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id:ID!): Post
    allPosts: [Post]
}

type Mutation {
    addPost(id: ID!, author: String!, title: String, content: String, url: String): Post!
}

type Post {
    id: ID!
    author: String!
    title: String
    content: String
    url: String
    ups: Int
    downs: Int
    relatedPosts: [Post]
}
```

Nella seguente query, la funzione Lambda verrà chiamata con batch di richieste da risolvere: `relatedPosts`

```
query getAllPosts {
  allPosts {
    id
    relatedPosts {
      id
    }
  }
}
```

Di seguito viene fornita una semplice implementazione di una funzione Lambda:

```
const posts = {
  1: {
    id: '1',
    title: 'First book',
    author: 'Author1',
    url: 'https://amazon.com/',
    content:
      'SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1 SAMPLE TEXT AUTHOR 1',
    ups: '100',
    downs: '10',
  },
  2: {
    id: '2',
    title: 'Second book',
    author: 'Author2',
    url: 'https://amazon.com',
    content: 'SAMPLE TEXT AUTHOR 2 SAMPLE TEXT AUTHOR 2 SAMPLE TEXT',
    ups: '100',
    downs: '10',
  },
  3: { id: '3', title: 'Third book', author: 'Author3', url: null, content: null, ups: null, downs: null },
  4: {
    id: '4',
    title: 'Fourth book',
    author: 'Author4',
    url: 'https://www.amazon.com/',
    content:
      'SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4 SAMPLE TEXT AUTHOR 4',
    ups: '1000',
    downs: '0',
  },
  5: {
    id: '5',
    title: 'Fifth book',
    author: 'Author5',
    url: 'https://www.amazon.com/',
    content: 'SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT AUTHOR 5 SAMPLE TEXT',
    ups: '50',
    downs: '0',
  },
}

const relatedPosts = {
  1: [posts['4']],
  2: [posts['3'], posts['5']],
  3: [posts['2'], posts['1']],
  4: [posts['2'], posts['1']],
  5: [],
}
exports.handler = async (event) => {
  console.log('event ->', event)
  // retrieve the ID of each post
  const ids = event.map((context) => context.source.id)
  // fetch the related posts for each post id
  const related = ids.map((id) => relatedPosts[id])

  // return the related posts; or an error if none were found
  return related.map((r) => {
    if (r.length > 0) {
      return { data: r }
    } else {
      return { data: null, errorMessage: 'Not found', errorType: 'ERROR' }
    }
  })
}
```

# AWS AppSync riferimento al modello di mappatura del resolver per EventBridge
<a name="resolver-mapping-template-reference-eventbridge"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Il modello di mappatura del AWS AppSync resolver utilizzato con l'origine EventBridge dati consente di inviare eventi personalizzati al bus Amazon. EventBridge 

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

Il modello di mappatura delle `PutEvents` richieste consente di inviare più eventi personalizzati a un EventBridge bus di eventi. Il documento di mappatura ha la seguente struttura:

```
{
    "version" : "2018-05-29", 
    "operation" : "PutEvents",
    "events" : [{}]
}
```

Di seguito è riportato un esempio di modello di mappatura delle richieste per: EventBridge 

```
{
    "version": "2018-05-29",
    "operation": "PutEvents",
    "events": [{
        "source": "com.mycompany.myapp",
        "detail": {
            "key1" : "value1",
            "key2" : "value2"
        },
        "detailType": "myDetailType1"
    },
    {
        "source": "com.mycompany.myapp",
        "detail": {
            "key3" : "value3",
            "key4" : "value4"
        },
        "detailType": "myDetailType2",
        "resources" : ["Resource1", "Resource2"],
        "time" : "2023-01-01T00:30:00.000Z"
    }
    
    ]
}
```

## Modello di mappatura delle risposte
<a name="response-mapping-template"></a>

Se l'`PutEvents`operazione ha esito positivo, la risposta di EventBridge è inclusa in: `$ctx.result`

```
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
#end
  $util.toJson($ctx.result)
```

Errori che si verificano durante l'esecuzione di `PutEvents` operazioni come `InternalExceptions` o `Timeouts` che verranno visualizzati in`$ctx.error`. Per un elenco degli EventBridge errori più comuni, consulta il [riferimento agli errori EventBridge comuni](https://docs.aws.amazon.com/eventbridge/latest/APIReference/CommonErrors.html).

`result`Sarà nel seguente formato:

```
{
    "Entries" [
        {
            "ErrorCode" : String,
            "ErrorMessage" : String,
            "EventId" : String
        }
    ],
    "FailedEntryCount" : number
}
```
+ **Iscrizioni**

  I risultati dell'evento ingerito, sia riusciti che infruttuosi. Se l'ingestione è andata a buon fine, la voce contiene il `EventID` In caso contrario, è possibile utilizzare il comando `ErrorCode` and `ErrorMessage` per identificare il problema relativo alla voce.

  Per ogni record, l'indice dell'elemento di risposta è lo stesso dell'indice nell'array di richiesta.
+ **FailedEntryCount**

  Il numero di inserimenti non riusciti. Questo valore è rappresentato come un numero intero.

Per ulteriori informazioni sulla risposta di`PutEvents`, vedere [PutEvents](https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutEvents.html#API_PutEvents_ResponseElements).

**Esempio di risposta 1**

L'esempio seguente è un'`PutEvents`operazione con due eventi riusciti:

```
{
    "Entries" : [ 
        {
            "EventId": "11710aed-b79e-4468-a20b-bb3c0c3b4860"
        }, 
        {
            "EventId": "d804d26a-88db-4b66-9eaf-9a11c708ae82"
        }
    ],
    "FailedEntryCount" : 0
}
```

**Esempio di risposta di esempio 2**

L'esempio seguente è un'`PutEvents`operazione con tre eventi, due riusciti e uno fallito:

```
{
    "Entries" : [ 
        {
            "EventId": "11710aed-b79e-4468-a20b-bb3c0c3b4860"
        }, 
        {
            "EventId": "d804d26a-88db-4b66-9eaf-9a11c708ae82"
        },
        {
            "ErrorCode" : "SampleErrorCode",
            "ErrorMessage" : "Sample Error Message"
        }
    ],
    "FailedEntryCount" : 1
}
```

## `PutEvents` campi
<a name="putevents-field"></a>

`PutEvents`contiene i seguenti campi del modello di mappatura:
+ **Versione**

  Comune a tutti i modelli di mappatura delle richieste, il `version` campo definisce la versione utilizzata dal modello. Questo campo è obbligatorio. Il valore `2018-05-29` è l'unica versione supportata per i modelli di EventBridge mappatura.
+ **Operazioni**

  L'unica operazione supportata è`PutEvents`. Questa operazione consente di aggiungere eventi personalizzati al bus degli eventi.
+ **Eventi**

  Una serie di eventi che verranno aggiunti all'event bus. Questo array dovrebbe avere un'allocazione di 1-10 elementi.

  L'`Event`oggetto è un oggetto JSON valido con i seguenti campi:
  + `"source"`: Una stringa che definisce l'origine dell'evento.
  + `"detail"`: un oggetto JSON che è possibile utilizzare per allegare informazioni sull'evento. Questo campo può essere una mappa vuota (`{ }`).
  + `"detailType`: Una stringa che identifica il tipo di evento.
  + `"resources"`: Un array di stringhe JSON che identifica le risorse coinvolte nell'evento. Questo campo può essere una matrice vuota.
  + `"time"`: Il timestamp dell'evento fornito come stringa. Questo dovrebbe seguire il formato del [RFC3339](https://www.rfc-editor.org/rfc/rfc3339.txt)timestamp.

I frammenti seguenti sono alcuni esempi di oggetti validi: `Event`

**Esempio 1**

```
{
    "source" : "source1",
    "detail" : {
        "key1" : [1,2,3,4],
        "key2" : "strval"
    },
    "detailType" : "sampleDetailType",
    "resources" : ["Resouce1", "Resource2"],
    "time" : "2022-01-10T05:00:10Z"
}
```

**Esempio 2**

```
{
    "source" : "source1",
    "detail" : {},
    "detailType" : "sampleDetailType"
}
```

**Esempio 3**

```
{
    "source" : "source1",
    "detail" : {
        "key1" : 1200
    },
    "detailType" : "sampleDetailType",
    "resources" : []
}
```

# AWS AppSync riferimento al modello di mappatura del resolver per l'origine dati `None`
<a name="resolver-mapping-template-reference-none"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

Il modello di mappatura del AWS AppSync resolver utilizzato con l'origine dati di tipo *None* consente di modellare le richieste per le operazioni locali. AWS AppSync 

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

Il modello di mappatura è semplice e permette di passare quante più informazioni sul contesto possibile tramite il campo `payload`.

```
{
   "version": string,
   "payload": any type
}
```

Di seguito è riportata la rappresentazione dello schema JSON del modello di mappatura della richiesta, dopo la risoluzione:

```
{
    "definitions": {},
    "$schema": "https://json-schema.org/draft-06/schema#",
    "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
    "type": "object",
    "properties": {
        "version": {
            "$id": "/properties/version",
            "type": "string",
            "enum": [
                "2018-05-29"
            ],
            "title": "The Mapping template version.",
            "default": "2018-05-29"
        },
        "payload": {}
    },
    "required": [
        "version"
    ],
    "additionalProperties": false
}
```

Ecco un esempio in cui gli argomenti del campo vengono passati tramite la proprietà di contesto VTL: `$context.arguments`

```
{
    "version": "2018-05-29",
    "payload": $util.toJson($context.arguments)
}
```

Il valore del campo `payload` verrà inoltrato al modello di mappatura della risposta e sarà disponibile nella proprietà di contesto VTL (`$context.result`).

Questo è un esempio che rappresenta il valore interpolato del campo `payload`:

```
{
    "id": "postId1"
}
```

## Versione
<a name="version"></a>

Comune a tutti i modelli di mappatura delle richieste, il `version` campo definisce la versione utilizzata dal modello.

 Il campo `version` è obbligatorio.

Esempio:

```
"version": "2018-05-29"
```

## Carico utile
<a name="payload"></a>

Il campo `payload` è un container che può essere usato per passare qualsiasi input JSON con formato corretto al modello di mappatura della risposta.

 Il campo `payload` è facoltativo.

## Modello di mappatura delle risposte
<a name="response-mapping-template"></a>

Poiché non è presente alcuna origine dati, il valore del campo `payload` verrà inoltrato al modello di mappatura della risposta e impostato sull'oggetto `context` che è disponibile tramite la proprietà `$context.result` VTL.

Se la forma del valore del campo `payload` corrisponde esattamente alla forma del tipo GraphQL, puoi inoltrare la risposta usando il modello di mappatura della risposta seguente:

```
$util.toJson($context.result)
```

Non ci sono campi obbligatori né restrizioni relative alla forma che si applicano al modello di mappatura della risposta. Tuttavia, poiché GraphQL è un protocollo fortemente tipizzato, il modello di mappatura risolto deve corrispondere al tipo GraphQL previsto.

# AWS AppSync riferimento al modello di mappatura del resolver per HTTP
<a name="resolver-mapping-template-reference-http"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

I modelli di mappatura del resolver AWS AppSync HTTP consentono di inviare richieste da qualsiasi endpoint HTTP e AWS AppSync di inviare risposte dall'endpoint HTTP a. AWS AppSync Utilizzando i modelli di mappatura, è possibile fornire suggerimenti AWS AppSync sulla natura dell'operazione da richiamare. In questa sezione vengono descritti i diversi modelli di mappatura per i resolver HTTP supportati.

## Richiedi un modello di mappatura
<a name="request-mapping-template"></a>

```
{
    "version": "2018-05-29",
    "method": "PUT|POST|GET|DELETE|PATCH",
    "params": {
        "query": Map,
        "headers": Map,
        "body": any
    },
    "resourcePath": string
}
```

Dopo che il modello di mappatura della richiesta HTTP è stato risolto, la rappresentazione dello schema JSON del modello di mappatura della richiesta è simile alla seguente:

```
{
    "$id": "https://aws.amazon.com/appsync/request-mapping-template.json",
    "type": "object",
    "properties": {
        "version": {
        "$id": "/properties/version",
        "type": "string",
        "title": "The Version Schema ",
        "default": "",
        "examples": [
            "2018-05-29"
        ],
        "enum": [
            "2018-05-29"
        ]
        },
        "method": {
        "$id": "/properties/method",
        "type": "string",
        "title": "The Method Schema ",
        "default": "",
        "examples": [
            "PUT|POST|GET|DELETE|PATCH"
        ],
        "enum": [
            "PUT",
            "PATCH",
            "POST",
            "DELETE",
            "GET"
        ]
        },
        "params": {
        "$id": "/properties/params",
        "type": "object",
        "properties": {
            "query": {
            "$id": "/properties/params/properties/query",
            "type": "object"
            },
            "headers": {
            "$id": "/properties/params/properties/headers",
            "type": "object"
            },
            "body": {
            "$id": "/properties/params/properties/body",
            "type": "string",
            "title": "The Body Schema ",
            "default": "",
            "examples": [
                ""
            ]
            }
        }
        },
        "resourcePath": {
        "$id": "/properties/resourcePath",
        "type": "string",
        "title": "The Resourcepath Schema ",
        "default": "",
        "examples": [
            ""
        ]
        }
    },
    "required": [
        "version",
        "method",
        "resourcePath"
    ]
}
```

Di seguito è riportato un esempio di richiesta HTTP POST con un corpo `text/plain`:

```
{
    "version": "2018-05-29",
    "method": "POST",
    "params": {
        "headers":{
        "Content-Type":"text/plain"
        },
        "body":"this is an example of text body"
    },
    "resourcePath": "/"
}
```

## Versione
<a name="version"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Definisce la versione usata dal modello. `version` è comune a tutti i modelli di mappatura della richiesta ed è obbligatorio.

```
"version": "2018-05-29"
```

## Metodo
<a name="method"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Metodo o verbo HTTP (GET, POST, PUT, PATCH o DELETE) che AWS AppSync invia all'endpoint HTTP.

```
"method": "PUT"
```

## ResourcePath
<a name="resourcepath"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Il percorso delle risorse a cui si desidera accedere. Oltre all'endpoint nell'origine dati HTTP, il percorso della risorsa costituisce l'URL a cui il AWS AppSync servizio effettua una richiesta.

```
"resourcePath": "/v1/users"
```

Quando il modello di mappatura viene valutato, questo percorso viene inviato come parte della richiesta HTTP, incluso l'endpoint HTTP. Ad esempio, l'esempio precedente potrebbe diventare il seguente:

```
PUT <endpoint>/v1/users
```

## Campi dei parametri
<a name="params-field"></a>

**Nota**  
Questo vale solo per il modello di mappatura Request. 

Usato per specificare l'operazione eseguita dalla ricerca, in genere impostando il valore **query** all'interno di **body**. Ci sono tuttavia numerose altre funzionalità che è possibile configurare, ad esempio la formattazione delle risposte.

** **headers** **  
Informazioni dell'intestazione, come coppie chiave-valore. Sia la chiave che il valore devono essere stringhe.  
Esempio:  

```
"headers" : {
    "Content-Type" : "application/json"
}
```
Le intestazioni `Content-Type` attualmente supportate sono:  

```
text/*
application/xml
application/json
application/soap+xml
application/x-amz-json-1.0
application/x-amz-json-1.1
application/vnd.api+json
application/x-ndjson
```
 **Nota**: non è possibile impostare le seguenti intestazioni HTTP:  

```
HOST
CONNECTION
USER-AGENT
EXPECTATION
TRANSFER_ENCODING
CONTENT_LENGTH
```

** **query** **  
Coppie chiave-valore che specificano opzioni comuni, ad esempio la formattazione del codice per le risposte JSON. Sia la chiave che il valore devono essere stringhe. L'esempio seguente mostra in che modo è possibile inviare una stringa di query come `?type=json`:  

```
"query" : {
    "type" : "json"
}
```

** **body** **  
Il corpo contiene il corpo della richiesta HTTP che si decide di impostare. La richiesta corpo è sempre una stringa con codifica UTF-8, a meno che il tipo di contenuto non specifichi il charset.  

```
"body":"body string"
```

## Risposta
<a name="response"></a>

Consulta un esempio [qui](https://docs.aws.amazon.com/appsync/latest/devguide/tutorial-http-resolvers.html).

# Autorità di certificazione (CA) riconosciute dagli AWS AppSync endpoint HTTPS
<a name="http-cert-authorities"></a>

**Nota**  
*Let's Encrypt è accettato tramite i certificati *identrust* e isrgrootx1.* Non è richiesta alcuna azione da parte tua se usi Let's Encrypt.

Al momento, i certificati autofirmati non sono supportati dai resolver HTTP quando si utilizza HTTPS. AWS AppSync riconosce le seguenti autorità di certificazione durante la risoluzione dei certificati SSL/TLS per HTTPS:


**Certificati root noti in AWS AppSync**  

| Nome | Data | SHA1 Impronta digitale | 
| --- | --- | --- | 
| digicertassuredidrootca | 21 aprile 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| trustcenterclass2caii | 21 aprile 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| thawtepremiumserverca | 21 aprile 2018 | E0:AB:05:94:20:72:54:93:05:60:62:02:36:70:F7:CD:2E:FC:66:66 | 
| cia-crt-g3-02-ca | 23 novembre 2016 | 96:4A:BB:A7:BD:DA:FC:97:34:C0:0A:2D:F0:05:98:F7:E6:C6:6F:09 | 
| swisssignplatinumg2ca | 21 aprile 2018 | 56:E0:FA:C0:3B:8F:18:23:55:18:E5:D3:11:CA:E8:C2:43:31:AB:66 | 
| swisssignsilverg2ca | 21 aprile 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| thawteserverca | 21 aprile 2018 | 9F:AD:91:A6:CE:6A:C6:C5:00:47:C4:4E:C9:D4:A5:0D:92:D8:49:79 | 
| equifaxsecureebusinessca1 | 21 aprile 2018 | AE:E6:3D:70:E3:76:FB:C7:3A:EB:B0:A1:C1:D4:C4:7A:A7:40:B3:F4 | 
| securetrustca | 21 aprile 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| utnuserfirstclientauthemailca | 21 aprile 2018 | B1:72:B1:A5:6D:95:F9:1F:E5:02:87:E1:4D:37:EA:6A:44:63:76:8A | 
| thawtepersonalfreemailca | 21 aprile 2018 | E6:18:83:AE:84:CA:C1:C1:CD:52:AD:E8:E9:25:2B:45:A6:4F:B7:E2 | 
| affirmtrustnetworkingca | 21 aprile 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| entrustevca | 21 aprile 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| utnuserfirsthardwareca | 21 aprile 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| certumca | 21 aprile 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| addtrustclass1ca | 21 aprile 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| entrustrootcag2 | 21 aprile 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| equifaxsecureca | 21 aprile 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| quovadisrootca3 | 21 aprile 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 21 aprile 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| digicertglobalrootg2 | 21 aprile 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| digicerthighassuranceevrootca | 21 aprile 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| secomvalicertclass1ca | 21 aprile 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| equifaxsecureglobalebusinessca1 | 21 aprile 2018 | 3A:74:CB:7A:47:DB:70:DE:89:1F:24:35:98:64:B8:2D:82:BD:1A:36 | 
| geotrustuniversalca | 21 aprile 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| deprecateditsecca | 27 gennaio 2012 | 12:12:0B:03:0E:15:14:54:F4:DD:B3:F5:DE:13:6E:83:5A:29:72:9D | 
| verisignclass3ca | 21 aprile 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| thawteprimaryrootcag3 | 21 aprile 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| thawteprimaryrootcag2 | 21 aprile 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| deutschetelekomrootca2 | 21 aprile 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| buypassclass3ca | 21 aprile 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| utnuserfirstobjectca | 21 aprile 2018 | E1:2D:FB:4B:41:D7:D9:C3:2B:30:51:4B:AC:1D:81:D8:38:5E:2D:46 | 
| geotrustprimaryca | 21 aprile 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| buypassclass2ca | 21 aprile 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| baltimorecodesigningca | 21 aprile 2018 | 30:46:D8:C8:88:FF:69:30:C3:4A:FC:CD:49:27:08:7C:60:56:7B:0D | 
| verisignclass1ca | 21 aprile 2018 | CE:6A:64:A3:09:E4:2F:BB:D9:85:1C:45:3E:64:09:EA:E8:7D:60:F1 | 
| baltimorecybertrustca | 21 aprile 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| starfieldclass2ca | 21 aprile 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| camerfirmachamberscommerceca | 21 aprile 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| ttelesecglobalrootclass3ca | 21 aprile 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| verisignclass3g5ca | 21 aprile 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| ttelesecglobalrootclass2ca | 21 aprile 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| trustcenteruniversalcai | 21 aprile 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| verisignclass3g4ca | 21 aprile 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3g3ca | 21 aprile 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| xrampglobalca | 21 aprile 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| amzninternalrootca | 12 dicembre 2008 | A7:B7:F6:15:8A:FF:1E:C8:85:13:38:BC:93:EB:A2:AB:A4:09:EF:06 | 
| certplusclass3pprimaryca | 21 aprile 2018 | 21:6B:2A:29:E6:2A:00:CE:82:01:46:D8:24:41:41:B9:25:11:B2:79 | 
| certumtrustednetworkca | 21 aprile 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| verisignclass3g2ca | 21 aprile 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| globalsignr3ca | 21 aprile 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| utndatacorpsgcca | 21 aprile 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| secomscrootca2 | 21 aprile 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| gtecybertrustglobalca | 21 aprile 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| secomscrootca1 | 21 aprile 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| affirmtrustcommercialca | 21 aprile 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| trustcenterclass4caii | 21 aprile 2018 | A6:9A:91:FD:05:7F:13:6A:42:63:0B:B1:76:0D:2D:51:12:0C:16:50 | 
| verisignuniversalrootca | 21 aprile 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| globalsignr2ca | 21 aprile 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| certplusclass2primaryca | 21 aprile 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| digicertglobalrootca | 21 aprile 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| globalsignca | 21 aprile 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| thawteprimaryrootca | 21 aprile 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| starfieldrootg2ca | 21 aprile 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| geotrustglobalca | 21 aprile 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| soneraclass2ca | 21 aprile 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| verisigntsaca | 21 aprile 2018 | 20:CE:B1:F0:F5:1C:0E:19:A9:F3:8D:B1:AA:8E:03:8C:AA:7A:C7:01 | 
| soneraclass1ca | 21 aprile 2018 | 07:47:22:01:99:CE:74:B9:7C:B0:3D:79:B2:64:A2:C8:55:E9:33:FF | 
| quovadisrootca | 21 aprile 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| affirmtrustpremiumeccca | 21 aprile 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| starfieldservicesrootg2ca | 21 aprile 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| valicertclass2ca | 21 aprile 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| comodoaaaca | 21 aprile 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| aolrootca2 | 21 aprile 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| keynectisrootca | 21 aprile 2018 | 9C:61:5C:4D:4D:85:10:3A:53:26:C2:4D:BA:EA:E4:A2:D2:D5:CC:97 | 
| addtrustqualifiedca | 21 aprile 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| aolrootca1 | 21 aprile 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| verisignclass2g3ca | 21 aprile 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| addtrustexternalca | 21 aprile 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| verisignclass2g2ca | 21 aprile 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| geotrustprimarycag3 | 21 aprile 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycag2 | 21 aprile 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| swisssigngoldg2ca | 21 aprile 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| entrust2048ca | 21 aprile 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| chunghwaepkirootca | 21 aprile 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| camerfirmachambersignca | 21 aprile 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| camerfirmachambersca | 21 aprile 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| godaddyclass2ca | 21 aprile 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| affirmtrustpremiumca | 21 aprile 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| verisignclass1g3ca | 21 aprile 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| secomevrootca1 | 21 aprile 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| verisignclass1g2ca | 21 aprile 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| amzninternalinfoseccag3 | 27 febbraio 2015 | B9:B1:CA:38:F7:BF:9C:D2:D4:95:E7:B6:5E:75:32:9B:A8:78:2E:F6 | 
| cia-crt-g3-01-ca | 23 novembre 2016 | 2B:EE:2C:BA:A3:1D:B5:FE:60:40:41:95:08:ED:46:82:39:4D:ED:E2 | 
| godaddyrootg2ca | 21 aprile 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| digicertassuredidrootca | 21 aprile 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| microseceszignorootca2009 | 21 aprile 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| affirmtrustcommercial | 21 aprile 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| comodoecccertificationauthority | 21 aprile 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| cadisigrootr2 | 21 aprile 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| swisssignsilvercag2 | 21 aprile 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| securetrustca | 21 aprile 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| cadisigrootr1 | 21 aprile 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| accvraiz1 | 21 aprile 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| entrustrootcertificationauthority | 21 aprile 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| camerfirmaglobalchambersignroot | 21 aprile 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| dstacescax6 | 21 aprile 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| identrustpublicsectorrootca1 | 21 aprile 2018 | BA:29:41:60:77:98:3F:F4:F3:EF:F2:31:05:3B:2E:EA:6D:4D:45:FD | 
| starfieldrootcertificateauthorityg2 | 21 aprile 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| secureglobalca | 21 aprile 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| eecertificationcentrerootca | 21 aprile 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| opentrustrootcag3 | 21 aprile 2018 | 6E:26:64:F3:56:BF:34:55:BF:D1:93:3F:7C:01:DE:D8:13:DA:8A:A6 | 
| teliasonerarootcav1 | 21 aprile 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| autoridaddecertificacionfirmaprofesionalcifa62634068 | 21 aprile 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| opentrustrootcag2 | 21 aprile 2018 | 79:5F:88:60:C5:AB:7C:3D:92:E6:CB:F4:8D:E1:45:CD:11:EF:60:0B | 
| opentrustrootcag1 | 21 aprile 2018 | 79:91:E8:34:F7:E2:EE:DD:08:95:01:52:E9:55:2D:14:E9:58:D5:7E | 
| globalsigneccrootcar5 | 21 aprile 2018 | 1F:24:C6:30:CD:A4:18:EF:20:69:FF:AD:4F:DD:5F:46:3A:1B:69:AA | 
| globalsigneccrootcar4 | 21 aprile 2018 | 69:69:56:2E:40:80:F4:24:A1:E7:19:9F:14:BA:F3:EE:58:AB:6A:BB | 
| izenpecom | 21 aprile 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| turktrustelektroniksertifikahizmetsaglayicisih5 | 21 aprile 2018 | C4:18:F6:4D:46:D1:DF:00:3D:27:30:13:72:43:A9:12:11:C6:75:FB | 
| gdcatrustauthr5root | 21 aprile 2018 | 0F:36:38:5B:81:1A:25:C3:9B:31:4E:83:CA:E9:34:66:70:CC:74:B4 | 
| dtrustrootclass3ca22009 | 21 aprile 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| quovadisrootca3 | 21 aprile 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 21 aprile 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| geotrustprimarycertificationauthorityg3 | 21 aprile 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycertificationauthorityg2 | 21 aprile 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| oistewisekeyglobalrootgbca | 21 aprile 2018 | 0F:F9:40:76:18:D3:D7:6A:4B:98:F0:A8:35:9E:0C:FD:27:AC:CC:ED | 
| addtrustexternalroot | 21 aprile 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| chambersofcommerceroot2008 | 21 aprile 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| digicertglobalrootg3 | 21 aprile 2018 | 7E:04:DE:89:6A:3E:66:6D:00:E6:87:D3:3F:FA:D9:3B:E8:3D:34:9E | 
| comodoaaaservicesroot | 21 aprile 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| digicertglobalrootg2 | 21 aprile 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| certinomisrootca | 21 aprile 2018 | 9D:70:BB:01:A5:A4:A0:18:11:2E:F7:1C:01:B9:32:C5:34:E7:88:A8 | 
| oistewisekeyglobalrootgaca | 21 aprile 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| dstrootcax3 | 21 aprile 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| certigna | 21 aprile 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| digicerthighassuranceevrootca | 21 aprile 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| soneraclass2rootca | 21 aprile 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| trustcorrootcertca2 | 21 aprile 2018 | B8:BE:6D:CB:56:F1:55:B9:63:D4:12:CA:4E:06:34:C7:94:B2:1C:C0 | 
| usertrustrsacertificationauthority | 21 aprile 2018 | 2B:8F:1B:57:33:0D:BB:A2:D0:7A:6C:51:F7:0E:E9:0D:DA:B9:AD:8E | 
| trustcorrootcertca1 | 21 aprile 2018 | FF:BD:CD:E7:82:C8:43:5E:3C:6F:26:86:5C:CA:A8:3A:45:5B:C3:0A | 
| geotrustuniversalca | 21 aprile 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| certsignrootca | 21 aprile 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| amazonrootca4 | 21 aprile 2018 | F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE | 
| amazonrootca3 | 21 aprile 2018 | 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E | 
| amazonrootca2 | 21 aprile 2018 | 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A | 
| verisignuniversalrootcertificationauthority | 21 aprile 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| amazonrootca1 | 21 aprile 2018 | 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16 | 
| networksolutionscertificateauthority | 21 aprile 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| thawteprimaryrootcag3 | 21 aprile 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| affirmtrustnetworking | 21 aprile 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| thawteprimaryrootcag2 | 21 aprile 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| trustcoreca1 | 21 aprile 2018 | 58:D1:DF:95:95:67:6B:63:C0:F0:5B:1C:17:4D:8B:84:0B:C8:78:BD | 
| deutschetelekomrootca2 | 21 aprile 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| godaddyrootcertificateauthorityg2 | 21 aprile 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| entrustrootcertificationauthorityec1 | 21 aprile 2018 | 20:D8:06:40:DF:9B:25:F5:12:25:3A:11:EA:F7:59:8A:EB:14:B5:47 | 
| szafirrootca2 | 21 aprile 2018 | E2:52:FA:95:3F:ED:DB:24:60:BD:6E:28:F3:9C:CC:CF:5E:B3:3F:DE | 
| tubitakkamusmsslkoksertifikasisurum1 | 21 aprile 2018 | 31:43:64:9B:EC:CE:27:EC:ED:3A:3F:0B:8F:0D:E4:E8:91:DD:EE:CA | 
| buypassclass3rootca | 21 aprile 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| comodorsacertificationauthority | 21 aprile 2018 | AF:E5:D2:44:A8:D1:19:42:30:FF:47:9F:E2:F8:97:BB:CD:7A:8C:B4 | 
| netlockaranyclassgoldfotanusitvany | 21 aprile 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| securitycommunicationrootca2 | 21 aprile 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| dtrustrootclass3ca2ev2009 | 21 aprile 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| starfieldclass2ca | 21 aprile 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| pscprocert | 21 aprile 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| actalisauthenticationrootca | 21 aprile 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| staatdernederlandenrootcag3 | 21 aprile 2018 | D8:EB:6B:41:51:92:59:E0:F3:E7:85:00:C0:3D:B6:88:97:C9:EE:FC | 
| cfcaevroot | 21 aprile 2018 | E2:B8:29:4B:55:84:AB:6B:58:C2:90:46:6C:AC:3F:B8:39:8F:84:83 | 
| digicerttrustedrootg4 | 21 aprile 2018 | DD:FB:16:CD:49:31:C9:73:A2:03:7D:3F:C8:3A:4D:7D:77:5D:05:E4 | 
| staatdernederlandenrootcag2 | 21 aprile 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| securitycommunicationevrootca1 | 21 aprile 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| globalsignrootcar3 | 21 aprile 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| globalsignrootcar2 | 21 aprile 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| certumtrustednetworkca2 | 21 aprile 2018 | D3:DD:48:3E:2B:BF:4C:05:E8:AF:10:F5:FA:76:26:CF:D3:DC:30:92 | 
| acraizfnmtrcm | 21 aprile 2018 | EC:50:35:07:B2:15:C4:95:62:19:E2:A8:9A:5B:42:99:2C:4C:2C:20 | 
| hellenicacademicandresearchinstitutionseccrootca2015 | 21 aprile 2018 | 9F:F1:71:8D:92:D5:9A:F3:7D:74:97:B4:BC:6F:84:68:0B:BA:B6:66 | 
| certplusrootcag2 | 21 aprile 2018 | 4F:65:8E:1F:E9:06:D8:28:02:E9:54:47:41:C9:54:25:5D:69:CC:1A | 
| twcarootcertificationauthority | 21 aprile 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| twcaglobalrootca | 21 aprile 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| certplusrootcag1 | 21 aprile 2018 | 22:FD:D0:B7:FD:A2:4E:0D:AC:49:2C:A0:AC:A6:7B:6A:1F:E3:F7:66 | 
| geotrustuniversalca2 | 21 aprile 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| baltimorecybertrustroot | 21 aprile 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| buypassclass2rootca | 21 aprile 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| certumtrustednetworkca | 21 aprile 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| digicertassuredidrootg3 | 21 aprile 2018 | F5:17:A2:4F:9A:48:C6:C9:F8:A2:00:26:9F:DC:0F:48:2C:AB:30:89 | 
| digicertassuredidrootg2 | 21 aprile 2018 | A1:4B:48:D9:43:EE:0A:0E:40:90:4F:3C:E0:A4:C0:91:93:51:5D:3F | 
| isrgrootx1 | 21 aprile 2018 | CA:BD:2A:79:A1:07:6A:31:F2:1D:25:36:35:CB:03:9D:43:29:A5:E8 | 
| entrustnetpremium2048secureserverca | 21 aprile 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| certplusclass2primaryca | 21 aprile 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| digicertglobalrootca | 21 aprile 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| entrustrootcertificationauthorityg2 | 21 aprile 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| starfieldservicesrootcertificateauthorityg2 | 21 aprile 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| thawteprimaryrootca | 21 aprile 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| atostrustedroot2011 | 21 aprile 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| geotrustglobalca | 21 aprile 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| luxtrustglobalroot2 | 21 aprile 2018 | 1E:0E:56:19:0A:D1:8B:25:98:B2:04:44:FF:66:8A:04:17:99:5F:3F | 
| etugracertificationauthority | 21 aprile 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| visaecommerceroot | 21 aprile 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| quovadisrootca | 21 aprile 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| identrustcommercialrootca1 | 21 aprile 2018 | DF:71:7E:AA:4A:D9:4E:C9:55:84:99:60:2D:48:DE:5F:BC:F0:3A:25 | 
| staatdernederlandenevrootca | 21 aprile 2018 | 76:E2:7E:C1:4F:DB:82:C1:C0:A6:75:B5:05:BE:3D:29:B4:ED:DB:BB | 
| ttelesecglobalrootclass3 | 21 aprile 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| ttelesecglobalrootclass2 | 21 aprile 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| comodocertificationauthority | 21 aprile 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| securitycommunicationrootca | 21 aprile 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| quovadisrootca3g3 | 21 aprile 2018 | 48:12:BD:92:3C:A8:C4:39:06:E7:30:6D:27:96:E6:A4:CF:22:2E:7D | 
| xrampglobalcaroot | 21 aprile 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| securesignrootca11 | 21 aprile 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| affirmtrustpremium | 21 aprile 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| globalsignrootca | 21 aprile 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| swisssigngoldcag2 | 21 aprile 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| quovadisrootca2g3 | 21 aprile 2018 | 09:3C:61:F3:8B:8B:DC:7D:55:DF:75:38:02:05:00:E1:25:F5:C8:36 | 
| affirmtrustpremiumecc | 21 aprile 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| geotrustprimarycertificationauthority | 21 aprile 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| quovadisrootca1g3 | 21 aprile 2018 | 1B:8E:EA:57:96:29:1A:C9:39:EA:B8:0A:81:1A:73:73:C0:93:79:67 | 
| hongkongpostrootca1 | 21 aprile 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| usertrustecccertificationauthority | 21 aprile 2018 | D1:CB:CA:5D:B2:D5:2A:7F:69:3B:67:4D:E5:F0:5A:1D:0C:95:7D:F0 | 
| cybertrustglobalroot | 21 aprile 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| godaddyclass2ca | 21 aprile 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| hellenicacademicandresearchinstitutionsrootca2015 | 21 aprile 2018 | 01:0C:06:95:A6:98:19:14:FF:BF:5F:C6:B0:B6:95:EA:29:E9:12:A6 | 
| ecacc | 21 aprile 2018 | 28:90:3A:63:5B:52:80:FA:E6:77:4C:0B:6D:A7:D6:BA:A6:4A:F2:E8 | 
| hellenicacademicandresearchinstitutionsrootca2011 | 21 aprile 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| verisignclass3publicprimarycertificationauthorityg5 | 21 aprile 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| verisignclass3publicprimarycertificationauthorityg4 | 21 aprile 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3publicprimarycertificationauthorityg3 | 21 aprile 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| trustisfpsrootca | 21 aprile 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| epkirootcertificationauthority | 21 aprile 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| globalchambersignroot2008 | 21 aprile 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| camerfirmachambersofcommerceroot | 21 aprile 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert81.pem | 13 marzo 2014 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| mozillacert99.pem | 13 marzo 2014 | F1:7F:6F:B6:31:DC:99:E3:A3:C8:7F:FE:1C:F1:81:10:88:D9:60:33 | 
| mozillacert145.pem | 13 marzo 2014 | 10:1D:FA:3F:D5:0B:CB:BB:9B:B5:60:0C:19:55:A4:1A:F4:73:3A:04 | 
| mozillacert37.pem | 13 marzo 2014 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert4.pem | 13 marzo 2014 | E3:92:51:2F:0A:CF:F5:05:DF:F6:DE:06:7F:75:37:E1:65:EA:57:4B | 
| mozillacert70.pem | 13 marzo 2014 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| mozillacert88.pem | 13 marzo 2014 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| mozillacert134.pem | 13 marzo 2014 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| mozillacert26.pem | 13 marzo 2014 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| mozillacert77.pem | 13 marzo 2014 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| mozillacert123.pem | 13 marzo 2014 | 2A:B6:28:48:5E:78:FB:F3:AD:9E:79:10:DD:6B:DF:99:72:2C:96:E5 | 
| mozillacert15.pem | 13 marzo 2014 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| mozillacert66.pem | 13 marzo 2014 | DD:E1:D2:A9:01:80:2E:1D:87:5E:84:B3:80:7E:4B:B1:FD:99:41:34 | 
| mozillacert112.pem | 13 marzo 2014 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| mozillacert55.pem | 13 marzo 2014 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| mozillacert101.pem | 13 marzo 2014 | 99:A6:9B:E6:1A:FE:88:6B:4D:2B:82:00:7C:B8:54:FC:31:7E:15:39 | 
| mozillacert119.pem | 13 marzo 2014 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| mozillacert44.pem | 13 marzo 2014 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| mozillacert108.pem | 13 marzo 2014 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| mozillacert95.pem | 13 marzo 2014 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert141.pem | 13 marzo 2014 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| mozillacert33.pem | 13 marzo 2014 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| mozillacert0.pem | 13 marzo 2014 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| mozillacert84.pem | 13 marzo 2014 | D3:C0:63:F2:19:ED:07:3E:34:AD:5D:75:0B:32:76:29:FF:D5:9A:F2 | 
| mozillacert130.pem | 13 marzo 2014 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert148.pem | 13 marzo 2014 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| mozillacert22.pem | 13 marzo 2014 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| mozillacert7.pem | 13 marzo 2014 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| mozillacert73.pem | 13 marzo 2014 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| mozillacert137.pem | 13 marzo 2014 | 4A:65:D5:F4:1D:EF:39:B8:B8:90:4A:4A:D3:64:81:33:CF:C7:A1:D1 | 
| mozillacert11.pem | 13 marzo 2014 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| mozillacert29.pem | 13 marzo 2014 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| mozillacert62.pem | 13 marzo 2014 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert126.pem | 13 marzo 2014 | 25:01:90:19:CF:FB:D9:99:1C:B7:68:25:74:8D:94:5F:30:93:95:42 | 
| mozillacert18.pem | 13 marzo 2014 | 79:98:A3:08:E1:4D:65:85:E6:C2:1E:15:3A:71:9F:BA:5A:D3:4A:D9 | 
| mozillacert51.pem | 13 marzo 2014 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| mozillacert69.pem | 13 marzo 2014 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| mozillacert115.pem | 13 marzo 2014 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert40.pem | 13 marzo 2014 | 80:25:EF:F4:6E:70:C8:D4:72:24:65:84:FE:40:3B:8A:8D:6A:DB:F5 | 
| mozillacert58.pem | 13 marzo 2014 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| mozillacert104.pem | 13 marzo 2014 | 4F:99:AA:93:FB:2B:D1:37:26:A1:99:4A:CE:7F:F0:05:F2:93:5D:1E | 
| mozillacert91.pem | 13 marzo 2014 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| mozillacert47.pem | 13 marzo 2014 | 1B:4B:39:61:26:27:6B:64:91:A2:68:6D:D7:02:43:21:2D:1F:1D:96 | 
| mozillacert80.pem | 13 marzo 2014 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert98.pem | 13 marzo 2014 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| mozillacert144.pem | 13 marzo 2014 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| mozillacert36.pem | 13 marzo 2014 | 23:88:C9:D3:71:CC:9E:96:3D:FF:7D:3C:A7:CE:FC:D6:25:EC:19:0D | 
| mozillacert3.pem | 13 marzo 2014 | 87:9F:4B:EE:05:DF:98:58:3B:E3:60:D6:33:E7:0D:3F:FE:98:71:AF | 
| mozillacert87.pem | 13 marzo 2014 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert133.pem | 13 marzo 2014 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| mozillacert25.pem | 13 marzo 2014 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| mozillacert76.pem | 13 marzo 2014 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert122.pem | 13 marzo 2014 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| mozillacert14.pem | 13 marzo 2014 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| mozillacert65.pem | 13 marzo 2014 | 69:BD:8C:F4:9C:D3:00:FB:59:2E:17:93:CA:55:6A:F3:EC:AA:35:FB | 
| mozillacert111.pem | 13 marzo 2014 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| mozillacert129.pem | 13 marzo 2014 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| mozillacert54.pem | 13 marzo 2014 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| mozillacert100.pem | 13 marzo 2014 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| mozillacert118.pem | 13 marzo 2014 | 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45 | 
| mozillacert151.pem | 13 marzo 2014 | AC:ED:5F:65:53:FD:25:CE:01:5F:1F:7A:48:3B:6A:74:9F:61:78:C6 | 
| mozillacert43.pem | 13 marzo 2014 | F9:CD:0E:2C:DA:76:24:C1:8F:BD:F0:F0:AB:B6:45:B8:F7:FE:D5:7A | 
| mozillacert107.pem | 13 marzo 2014 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| mozillacert94.pem | 13 marzo 2014 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| mozillacert140.pem | 13 marzo 2014 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert32.pem | 13 marzo 2014 | 60:D6:89:74:B5:C2:65:9E:8A:0F:C1:88:7C:88:D2:46:69:1B:18:2C | 
| mozillacert83.pem | 13 marzo 2014 | A0:73:E5:C5:BD:43:61:0D:86:4C:21:13:0A:85:58:57:CC:9C:EA:46 | 
| mozillacert147.pem | 13 marzo 2014 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| mozillacert21.pem | 13 marzo 2014 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| mozillacert39.pem | 13 marzo 2014 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| mozillacert6.pem | 13 marzo 2014 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| mozillacert72.pem | 13 marzo 2014 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| mozillacert136.pem | 13 marzo 2014 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert10.pem | 13 marzo 2014 | 5F:3A:FC:0A:8B:64:F6:86:67:34:74:DF:7E:A9:A2:FE:F9:FA:7A:51 | 
| mozillacert28.pem | 13 marzo 2014 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| mozillacert61.pem | 13 marzo 2014 | E0:B4:32:2E:B2:F6:A5:68:B6:54:53:84:48:18:4A:50:36:87:43:84 | 
| mozillacert79.pem | 13 marzo 2014 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert125.pem | 13 marzo 2014 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert17.pem | 13 marzo 2014 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| mozillacert50.pem | 13 marzo 2014 | 8C:96:BA:EB:DD:2B:07:07:48:EE:30:32:66:A0:F3:98:6E:7C:AE:58 | 
| mozillacert68.pem | 13 marzo 2014 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| mozillacert114.pem | 13 marzo 2014 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert57.pem | 13 marzo 2014 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| mozillacert103.pem | 13 marzo 2014 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert90.pem | 13 marzo 2014 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| mozillacert46.pem | 13 marzo 2014 | 40:9D:4B:D9:17:B5:5C:27:B6:9B:64:CB:98:22:44:0D:CD:09:B8:89 | 
| mozillacert97.pem | 13 marzo 2014 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| mozillacert143.pem | 13 marzo 2014 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| mozillacert35.pem | 13 marzo 2014 | 2A:C8:D5:8B:57:CE:BF:2F:49:AF:F2:FC:76:8F:51:14:62:90:7A:41 | 
| mozillacert2.pem | 13 marzo 2014 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| mozillacert86.pem | 13 marzo 2014 | 74:2C:31:92:E6:07:E4:24:EB:45:49:54:2B:E1:BB:C5:3E:61:74:E2 | 
| mozillacert132.pem | 13 marzo 2014 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| mozillacert24.pem | 13 marzo 2014 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| mozillacert9.pem | 13 marzo 2014 | F4:8B:11:BF:DE:AB:BE:94:54:20:71:E6:41:DE:6B:BE:88:2B:40:B9 | 
| mozillacert75.pem | 13 marzo 2014 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| mozillacert121.pem | 13 marzo 2014 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| mozillacert139.pem | 13 marzo 2014 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| mozillacert13.pem | 13 marzo 2014 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| mozillacert64.pem | 13 marzo 2014 | 62:7F:8D:78:27:65:63:99:D2:7D:7F:90:44:C9:FE:B3:F3:3E:FA:9A | 
| mozillacert110.pem | 13 marzo 2014 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert128.pem | 13 marzo 2014 | A9:E9:78:08:14:37:58:88:F2:05:19:B0:6D:2B:0D:2B:60:16:90:7D | 
| mozillacert53.pem | 13 marzo 2014 | 7F:8A:B0:CF:D0:51:87:6A:66:F3:36:0F:47:C8:8D:8C:D3:35:FC:74 | 
| mozillacert117.pem | 13 marzo 2014 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| mozillacert150.pem | 13 marzo 2014 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| mozillacert42.pem | 13 marzo 2014 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| mozillacert106.pem | 13 marzo 2014 | E7:A1:90:29:D3:D5:52:DC:0D:0F:C6:92:D3:EA:88:0D:15:2E:1A:6B | 
| mozillacert93.pem | 13 marzo 2014 | 31:F1:FD:68:22:63:20:EE:C6:3B:3F:9D:EA:4A:3E:53:7C:7C:39:17 | 
| mozillacert31.pem | 13 marzo 2014 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| mozillacert49.pem | 13 marzo 2014 | 61:57:3A:11:DF:0E:D8:7E:D5:92:65:22:EA:D0:56:D7:44:B3:23:71 | 
| mozillacert82.pem | 13 marzo 2014 | 2E:14:DA:EC:28:F0:FA:1E:8E:38:9A:4E:AB:EB:26:C0:0A:D3:83:C3 | 
| mozillacert146.pem | 13 marzo 2014 | 21:FC:BD:8E:7F:6C:AF:05:1B:D1:B3:43:EC:A8:E7:61:47:F2:0F:8A | 
| mozillacert20.pem | 13 marzo 2014 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert38.pem | 13 marzo 2014 | CB:A1:C5:F8:B0:E3:5E:B8:B9:45:12:D3:F9:34:A2:E9:06:10:D3:36 | 
| mozillacert5.pem | 13 marzo 2014 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| mozillacert71.pem | 13 marzo 2014 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert89.pem | 13 marzo 2014 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| mozillacert135.pem | 13 marzo 2014 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert27.pem | 13 marzo 2014 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| mozillacert60.pem | 13 marzo 2014 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| mozillacert78.pem | 13 marzo 2014 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert124.pem | 13 marzo 2014 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert16.pem | 13 marzo 2014 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| mozillacert67.pem | 13 marzo 2014 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| mozillacert113.pem | 13 marzo 2014 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| mozillacert56.pem | 13 marzo 2014 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| mozillacert102.pem | 13 marzo 2014 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| mozillacert45.pem | 13 marzo 2014 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert109.pem | 13 marzo 2014 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| mozillacert96.pem | 13 marzo 2014 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| mozillacert142.pem | 13 marzo 2014 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| mozillacert34.pem | 13 marzo 2014 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| mozillacert1.pem | 13 marzo 2014 | 23:E5:94:94:51:95:F2:41:48:03:B4:D5:64:D2:A3:A3:F5:D8:8B:8C | 
| mozillacert85.pem | 13 marzo 2014 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| mozillacert131.pem | 13 marzo 2014 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| mozillacert149.pem | 13 marzo 2014 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert23.pem | 13 marzo 2014 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| mozillacert8.pem | 13 marzo 2014 | 3E:2B:F7:F2:03:1B:96:F3:8C:E6:C4:D8:A8:5D:3E:2D:58:47:6A:0F | 
| mozillacert74.pem | 13 marzo 2014 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert120.pem | 13 marzo 2014 | DA:40:18:8B:91:89:A3:ED:EE:AE:DA:97:FE:2F:9D:F5:B7:D1:8A:41 | 
| mozillacert138.pem | 13 marzo 2014 | E1:9F:E3:0E:8B:84:60:9E:80:9B:17:0D:72:A8:C5:BA:6E:14:09:BD | 
| mozillacert12.pem | 13 marzo 2014 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| mozillacert63.pem | 13 marzo 2014 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| mozillacert127.pem | 13 marzo 2014 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert19.pem | 13 marzo 2014 | B4:35:D4:E1:11:9D:1C:66:90:A7:49:EB:B3:94:BD:63:7B:A7:82:B7 | 
| mozillacert52.pem | 13 marzo 2014 | 8B:AF:4C:9B:1D:F0:2A:92:F7:DA:12:8E:B9:1B:AC:F4:98:60:4B:6F | 
| mozillacert116.pem | 13 marzo 2014 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert41.pem | 13 marzo 2014 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| mozillacert59.pem | 13 marzo 2014 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| mozillacert105.pem | 13 marzo 2014 | 77:47:4F:C6:30:E4:0F:4C:47:64:3F:84:BA:B8:C6:95:4A:8A:41:EC | 
| mozillacert92.pem | 13 marzo 2014 | A3:F1:33:3F:E2:42:BF:CF:C5:D1:4E:8F:39:42:98:40:68:10:D1:A0 | 
| mozillacert30.pem | 13 marzo 2014 | E7:B4:F6:9D:61:EC:90:69:DB:7E:90:A7:40:1A:3C:F4:7D:4F:E8:EE | 
| mozillacert48.pem | 13 marzo 2014 | A0:A1:AB:90:C9:FC:84:7B:3B:12:61:E8:97:7D:5F:D3:22:61:D3:CC | 
| verisignc4g2.pem | 20 marzo 2014 | 0B:77:BE:BB:CB:7A:A2:47:05:DE:CC:0F:BD:6A:02:FC:7A:BD:9B:52 | 
| verisignc2g3.pem | 20 marzo 2014 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| verisignc1g6.pem | 31 dicembre 2014 | 51:7F:61:1E:29:91:6B:53:82:FB:72:E7:44:D9:8D:C3:CC:53:6D:64 | 
| verisignc2g2.pem | 20 marzo 2014 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| verisignroot.pem | 20 marzo 2014 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| verisignc2g1.pem | 20 marzo 2014 | 67:82:AA:E0:ED:EE:E2:1A:58:39:D3:C0:CD:14:68:0A:4F:60:14:2A | 
| verisignc3g5.pem | 20 marzo 2014 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| verisignc1g3.pem | 20 marzo 2014 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| verisignc3g4.pem | 20 marzo 2014 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignc1g2.pem | 20 marzo 2014 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| verisignc3g3.pem | 20 marzo 2014 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| verisignc1g1.pem | 20 marzo 2014 | 90:AE:A2:69:85:FF:14:80:4C:43:49:52:EC:E9:60:84:77:AF:55:6F | 
| verisignc3g2.pem | 20 marzo 2014 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| verisignc3g1.pem | 20 marzo 2014 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| verisignc2g6.pem | 31 dicembre 2014 | 40:B3:31:A0:E9:BF:E8:55:BC:39:93:CA:70:4F:4E:C2:51:D4:1D:8F | 
| verisignc4g3.pem | 20 marzo 2014 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| gdroot-g2.pem | 31 dicembre 2014 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| gd-class2-root.pem | 31 dicembre 2014 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| gd\$1bundle-g2.pem | 31 dicembre 2014 | 27:AC:93:69:FA:F2:52:07:BB:26:27:CE:FA:CC:BE:4E:F9:C3:19:B8 | 
| dstacescax6 | 18 giugno 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| gd\$1bundle-g2.pem | 18 giugno 2018 | 27:AC:93:69:FA:F2:52:07:BB:26:27:CE:FA:CC:BE:4E:F9:C3:19:B8 | 
| verisignc4g3.pem | 18 giugno 2018 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| swisssignplatinumg2ca | 21 aprile 2018 | 56:E0:FA:C0:3B:8F:18:23:55:18:E5:D3:11:CA:E8:C2:43:31:AB:66 | 
| geotrustprimarycertificationauthorityg3 | 18 giugno 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| geotrustprimarycertificationauthorityg2 | 18 giugno 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| buypassclass2rootca | 18 giugno 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| camerfirmachambersofcommerceroot | 18 giugno 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| mozillacert20.pem | 18 giugno 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert12.pem | 18 giugno 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| mozillacert90.pem | 18 giugno 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| mozillacert82.pem | 18 giugno 2018 | 2E:14:DA:EC:28:F0:FA:1E:8E:38:9A:4E:AB:EB:26:C0:0A:D3:83:C3 | 
| mozillacert140.pem | 18 giugno 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert74.pem | 18 giugno 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert132.pem | 18 giugno 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| mozillacert66.pem | 18 giugno 2018 | DD:E1:D2:A9:01:80:2E:1D:87:5E:84:B3:80:7E:4B:B1:FD:99:41:34 | 
| mozillacert124.pem | 18 giugno 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert58.pem | 18 giugno 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| securitycommunicationrootca2 | 18 giugno 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert116.pem | 18 giugno 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert108.pem | 18 giugno 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| certigna | 18 giugno 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert3.pem | 18 giugno 2018 | 87:9F:4B:EE:05:DF:98:58:3B:E3:60:D6:33:E7:0D:3F:FE:98:71:AF | 
| verisignc1g1.pem | 18 giugno 2018 | 90:AE:A2:69:85:FF:14:80:4C:43:49:52:EC:E9:60:84:77:AF:55:6F | 
| verisignc4g2.pem | 18 giugno 2018 | 0B:77:BE:BB:CB:7A:A2:47:05:DE:CC:0F:BD:6A:02:FC:7A:BD:9B:52 | 
| deutschetelekomrootca2 | 18 giugno 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| starfieldrootg2ca | 21 aprile 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| comodoecccertificationauthority | 18 giugno 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| digicertglobalrootg3 | 18 giugno 2018 | 7E:04:DE:89:6A:3E:66:6D:00:E6:87:D3:3F:FA:D9:3B:E8:3D:34:9E | 
| digicertglobalrootg2 | 18 giugno 2018 | DF:3C:24:F9:BF:D6:66:76:1B:26:80:73:FE:06:D1:CC:8D:4F:82:A4 | 
| mozillacert11.pem | 18 giugno 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| mozillacert81.pem | 18 giugno 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| mozillacert73.pem | 18 giugno 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| szafirrootca2 | 18 giugno 2018 | E2:52:FA:95:3F:ED:DB:24:60:BD:6E:28:F3:9C:CC:CF:5E:B3:3F:DE | 
| mozillacert131.pem | 18 giugno 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| ecacc | 18 giugno 2018 | 28:90:3A:63:5B:52:80:FA:E6:77:4C:0B:6D:A7:D6:BA:A6:4A:F2:E8 | 
| mozillacert65.pem | 18 giugno 2018 | 69:BD:8C:F4:9C:D3:00:FB:59:2E:17:93:CA:55:6A:F3:EC:AA:35:FB | 
| turktrustelektroniksertifikahizmetsaglayicisih5 | 18 giugno 2018 | C4:18:F6:4D:46:D1:DF:00:3D:27:30:13:72:43:A9:12:11:C6:75:FB | 
| mozillacert123.pem | 18 giugno 2018 | 2A:B6:28:48:5E:78:FB:F3:AD:9E:79:10:DD:6B:DF:99:72:2C:96:E5 | 
| mozillacert57.pem | 18 giugno 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| mozillacert115.pem | 18 giugno 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert49.pem | 18 giugno 2018 | 61:57:3A:11:DF:0E:D8:7E:D5:92:65:22:EA:D0:56:D7:44:B3:23:71 | 
| mozillacert107.pem | 18 giugno 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| verisignclass3g4ca | 21 aprile 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| securetrustca | 18 giugno 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| mozillacert2.pem | 18 giugno 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| buypassclass2ca | 21 aprile 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| secomscrootca2 | 21 aprile 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| secomscrootca1 | 21 aprile 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| trustisfpsrootca | 18 giugno 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| hongkongpostrootca1 | 18 giugno 2018 | D6:DA:A8:20:8D:09:D2:15:4D:24:B5:2F:CB:34:6E:B2:58:B2:8A:58 | 
| certsignrootca | 18 giugno 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| geotrustprimaryca | 21 aprile 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| twcaglobalrootca | 18 giugno 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| camerfirmachambersca | 21 aprile 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| mozillacert10.pem | 18 giugno 2018 | 5F:3A:FC:0A:8B:64:F6:86:67:34:74:DF:7E:A9:A2:FE:F9:FA:7A:51 | 
| mozillacert80.pem | 18 giugno 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert72.pem | 18 giugno 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| comodoaaaca | 21 aprile 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert130.pem | 18 giugno 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert64.pem | 18 giugno 2018 | 62:7F:8D:78:27:65:63:99:D2:7D:7F:90:44:C9:FE:B3:F3:3E:FA:9A | 
| mozillacert122.pem | 18 giugno 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| mozillacert56.pem | 18 giugno 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| equifaxsecureebusinessca1 | 21 aprile 2018 | AE:E6:3D:70:E3:76:FB:C7:3A:EB:B0:A1:C1:D4:C4:7A:A7:40:B3:F4 | 
| camerfirmachambersignca | 21 aprile 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert114.pem | 18 giugno 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert48.pem | 18 giugno 2018 | A0:A1:AB:90:C9:FC:84:7B:3B:12:61:E8:97:7D:5F:D3:22:61:D3:CC | 
| pscprocert | 18 giugno 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert106.pem | 18 giugno 2018 | E7:A1:90:29:D3:D5:52:DC:0D:0F:C6:92:D3:EA:88:0D:15:2E:1A:6B | 
| mozillacert1.pem | 18 giugno 2018 | 23:E5:94:94:51:95:F2:41:48:03:B4:D5:64:D2:A3:A3:F5:D8:8B:8C | 
| eecertificationcentrerootca | 18 giugno 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| digicertglobalrootca | 18 giugno 2018 | A8:98:5D:3A:65:E5:E5:C4:B2:D7:D6:6D:40:C6:DD:2F:B1:9C:54:36 | 
| thawteprimaryrootcag3 | 18 giugno 2018 | F1:8B:53:8D:1B:E9:03:B6:A6:F0:56:43:5B:17:15:89:CA:F3:6B:F2 | 
| thawteprimaryrootcag2 | 18 giugno 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| entrustrootcertificationauthorityec1 | 18 giugno 2018 | 20:D8:06:40:DF:9B:25:F5:12:25:3A:11:EA:F7:59:8A:EB:14:B5:47 | 
| valicertclass2ca | 21 aprile 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| globalchambersignroot2008 | 18 giugno 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| amazonrootca4 | 18 giugno 2018 | F6:10:84:07:D6:F8:BB:67:98:0C:C2:E2:44:C2:EB:AE:1C:EF:63:BE | 
| gd-class2-root.pem | 18 giugno 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| amazonrootca3 | 18 giugno 2018 | 0D:44:DD:8C:3C:8C:1A:1A:58:75:64:81:E9:0F:2E:2A:FF:B3:D2:6E | 
| amazonrootca2 | 18 giugno 2018 | 5A:8C:EF:45:D7:A6:98:59:76:7A:8C:8B:44:96:B5:78:CF:47:4B:1A | 
| securitycommunicationrootca | 18 giugno 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| amazonrootca1 | 18 giugno 2018 | 8D:A7:F9:65:EC:5E:FC:37:91:0F:1C:6E:59:FD:C1:CC:6A:6E:DE:16 | 
| acraizfnmtrcm | 18 giugno 2018 | EC:50:35:07:B2:15:C4:95:62:19:E2:A8:9A:5B:42:99:2C:4C:2C:20 | 
| quovadisrootca3g3 | 18 giugno 2018 | 48:12:BD:92:3C:A8:C4:39:06:E7:30:6D:27:96:E6:A4:CF:22:2E:7D | 
| certplusrootcag2 | 18 giugno 2018 | 4F:65:8E:1F:E9:06:D8:28:02:E9:54:47:41:C9:54:25:5D:69:CC:1A | 
| certplusrootcag1 | 18 giugno 2018 | 22:FD:D0:B7:FD:A2:4E:0D:AC:49:2C:A0:AC:A6:7B:6A:1F:E3:F7:66 | 
| mozillacert71.pem | 18 giugno 2018 | 4A:BD:EE:EC:95:0D:35:9C:89:AE:C7:52:A1:2C:5B:29:F6:D6:AA:0C | 
| mozillacert63.pem | 18 giugno 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| mozillacert121.pem | 18 giugno 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| ttelesecglobalrootclass3ca | 21 aprile 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| mozillacert55.pem | 18 giugno 2018 | AA:DB:BC:22:23:8F:C4:01:A1:27:BB:38:DD:F4:1D:DB:08:9E:F0:12 | 
| mozillacert113.pem | 18 giugno 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| baltimorecybertrustca | 21 aprile 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| mozillacert47.pem | 18 giugno 2018 | 1B:4B:39:61:26:27:6B:64:91:A2:68:6D:D7:02:43:21:2D:1F:1D:96 | 
| mozillacert105.pem | 18 giugno 2018 | 77:47:4F:C6:30:E4:0F:4C:47:64:3F:84:BA:B8:C6:95:4A:8A:41:EC | 
| mozillacert39.pem | 18 giugno 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| usertrustecccertificationauthority | 18 giugno 2018 | D1:CB:CA:5D:B2:D5:2A:7F:69:3B:67:4D:E5:F0:5A:1D:0C:95:7D:F0 | 
| mozillacert0.pem | 18 giugno 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| securitycommunicationevrootca1 | 18 giugno 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| verisignc3g5.pem | 18 giugno 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| globalsignr3ca | 21 aprile 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| trustcoreca1 | 18 giugno 2018 | 58:D1:DF:95:95:67:6B:63:C0:F0:5B:1C:17:4D:8B:84:0B:C8:78:BD | 
| equifaxsecureglobalebusinessca1 | 21 aprile 2018 | 3A:74:CB:7A:47:DB:70:DE:89:1F:24:35:98:64:B8:2D:82:BD:1A:36 | 
| geotrustuniversalca | 18 giugno 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| affirmtrustpremiumca | 21 aprile 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| staatdernederlandenrootcag3 | 18 giugno 2018 | D8:EB:6B:41:51:92:59:E0:F3:E7:85:00:C0:3D:B6:88:97:C9:EE:FC | 
| staatdernederlandenrootcag2 | 18 giugno 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| mozillacert70.pem | 18 giugno 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| secomevrootca1 | 21 aprile 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| geotrustglobalca | 18 giugno 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert62.pem | 18 giugno 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert120.pem | 18 giugno 2018 | DA:40:18:8B:91:89:A3:ED:EE:AE:DA:97:FE:2F:9D:F5:B7:D1:8A:41 | 
| mozillacert54.pem | 18 giugno 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| mozillacert112.pem | 18 giugno 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| mozillacert46.pem | 18 giugno 2018 | 40:9D:4B:D9:17:B5:5C:27:B6:9B:64:CB:98:22:44:0D:CD:09:B8:89 | 
| swisssigngoldcag2 | 18 giugno 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert104.pem | 18 giugno 2018 | 4F:99:AA:93:FB:2B:D1:37:26:A1:99:4A:CE:7F:F0:05:F2:93:5D:1E | 
| mozillacert38.pem | 18 giugno 2018 | CB:A1:C5:F8:B0:E3:5E:B8:B9:45:12:D3:F9:34:A2:E9:06:10:D3:36 | 
| certplusclass3pprimaryca | 21 aprile 2018 | 21:6B:2A:29:E6:2A:00:CE:82:01:46:D8:24:41:41:B9:25:11:B2:79 | 
| entrustrootcertificationauthorityg2 | 18 giugno 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| godaddyrootg2ca | 21 aprile 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| cfcaevroot | 18 giugno 2018 | E2:B8:29:4B:55:84:AB:6B:58:C2:90:46:6C:AC:3F:B8:39:8F:84:83 | 
| verisignc3g4.pem | 18 giugno 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| geotrustuniversalca2 | 18 giugno 2018 | 37:9A:19:7B:41:85:45:35:0C:A6:03:69:F3:3C:2E:AF:47:4F:20:79 | 
| starfieldservicesrootg2ca | 21 aprile 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| digicerthighassuranceevrootca | 18 giugno 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| entrustnetpremium2048secureserverca | 18 giugno 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| camerfirmaglobalchambersignroot | 18 giugno 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| verisignclass3g3ca | 21 aprile 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| godaddyclass2ca | 18 giugno 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| mozillacert61.pem | 18 giugno 2018 | E0:B4:32:2E:B2:F6:A5:68:B6:54:53:84:48:18:4A:50:36:87:43:84 | 
| mozillacert53.pem | 18 giugno 2018 | 7F:8A:B0:CF:D0:51:87:6A:66:F3:36:0F:47:C8:8D:8C:D3:35:FC:74 | 
| atostrustedroot2011 | 18 giugno 2018 | 2B:B1:F5:3E:55:0C:1D:C5:F1:D4:E6:B7:6A:46:4B:55:06:02:AC:21 | 
| mozillacert111.pem | 18 giugno 2018 | 9C:BB:48:53:F6:A4:F6:D3:52:A4:E8:32:52:55:60:13:F5:AD:AF:65 | 
| staatdernederlandenevrootca | 18 giugno 2018 | 76:E2:7E:C1:4F:DB:82:C1:C0:A6:75:B5:05:BE:3D:29:B4:ED:DB:BB | 
| mozillacert45.pem | 18 giugno 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert103.pem | 18 giugno 2018 | 70:C1:8D:74:B4:28:81:0A:E4:FD:A5:75:D7:01:9F:99:B0:3D:50:74 | 
| mozillacert37.pem | 18 giugno 2018 | B1:2E:13:63:45:86:A4:6F:1A:B2:60:68:37:58:2D:C4:AC:FD:94:97 | 
| mozillacert29.pem | 18 giugno 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| izenpecom | 18 giugno 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| comodorsacertificationauthority | 18 giugno 2018 | AF:E5:D2:44:A8:D1:19:42:30:FF:47:9F:E2:F8:97:BB:CD:7A:8C:B4 | 
| mozillacert99.pem | 18 giugno 2018 | F1:7F:6F:B6:31:DC:99:E3:A3:C8:7F:FE:1C:F1:81:10:88:D9:60:33 | 
| mozillacert149.pem | 18 giugno 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| utnuserfirstobjectca | 21 aprile 2018 | E1:2D:FB:4B:41:D7:D9:C3:2B:30:51:4B:AC:1D:81:D8:38:5E:2D:46 | 
| verisignc3g3.pem | 18 giugno 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| dstrootcax3 | 18 giugno 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| addtrustexternalroot | 18 giugno 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| certumtrustednetworkca | 18 giugno 2018 | 07:E0:32:E0:20:B7:2C:3F:19:2F:06:28:A2:59:3A:19:A7:0F:06:9E | 
| affirmtrustpremiumecc | 18 giugno 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| starfieldclass2ca | 18 giugno 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| actalisauthenticationrootca | 18 giugno 2018 | F3:73:B3:87:06:5A:28:84:8A:F2:F3:4A:CE:19:2B:DD:C7:8E:9C:AC | 
| verisignclass2g3ca | 21 aprile 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| isrgrootx1 | 18 giugno 2018 | CA:BD:2A:79:A1:07:6A:31:F2:1D:25:36:35:CB:03:9D:43:29:A5:E8 | 
| godaddyrootcertificateauthorityg2 | 18 giugno 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| mozillacert60.pem | 18 giugno 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| chunghwaepkirootca | 21 aprile 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert52.pem | 18 giugno 2018 | 8B:AF:4C:9B:1D:F0:2A:92:F7:DA:12:8E:B9:1B:AC:F4:98:60:4B:6F | 
| microseceszignorootca2009 | 18 giugno 2018 | 89:DF:74:FE:5C:F4:0F:4A:80:F9:E3:37:7D:54:DA:91:E1:01:31:8E | 
| securesignrootca11 | 18 giugno 2018 | 3B:C4:9F:48:F8:F3:73:A0:9C:1E:BD:F8:5B:B1:C3:65:C7:D8:11:B3 | 
| mozillacert110.pem | 18 giugno 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert44.pem | 18 giugno 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| mozillacert102.pem | 18 giugno 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| mozillacert36.pem | 18 giugno 2018 | 23:88:C9:D3:71:CC:9E:96:3D:FF:7D:3C:A7:CE:FC:D6:25:EC:19:0D | 
| mozillacert28.pem | 18 giugno 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| baltimorecybertrustroot | 18 giugno 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| amzninternalrootca | 12 dicembre 2008 | A7:B7:F6:15:8A:FF:1E:C8:85:13:38:BC:93:EB:A2:AB:A4:09:EF:06 | 
| mozillacert98.pem | 18 giugno 2018 | C9:A8:B9:E7:55:80:5E:58:E3:53:77:A7:25:EB:AF:C3:7B:27:CC:D7 | 
| mozillacert148.pem | 18 giugno 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| verisignc3g2.pem | 18 giugno 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| quovadisrootca2g3 | 18 giugno 2018 | 09:3C:61:F3:8B:8B:DC:7D:55:DF:75:38:02:05:00:E1:25:F5:C8:36 | 
| geotrustprimarycertificationauthority | 18 giugno 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| opentrustrootcag3 | 18 giugno 2018 | 6E:26:64:F3:56:BF:34:55:BF:D1:93:3F:7C:01:DE:D8:13:DA:8A:A6 | 
| opentrustrootcag2 | 18 giugno 2018 | 79:5F:88:60:C5:AB:7C:3D:92:E6:CB:F4:8D:E1:45:CD:11:EF:60:0B | 
| opentrustrootcag1 | 18 giugno 2018 | 79:91:E8:34:F7:E2:EE:DD:08:95:01:52:E9:55:2D:14:E9:58:D5:7E | 
| verisignclass3ca | 21 aprile 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| globalsignca | 21 aprile 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| ttelesecglobalrootclass2ca | 21 aprile 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| verisignclass1g3ca | 21 aprile 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| verisignuniversalrootca | 21 aprile 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| soneraclass2ca | 21 aprile 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| starfieldservicesrootcertificateauthorityg2 | 18 giugno 2018 | 92:5A:8F:8D:2C:6D:04:E0:66:5F:59:6A:FF:22:D8:63:E8:25:6F:3F | 
| mozillacert51.pem | 18 giugno 2018 | FA:B7:EE:36:97:26:62:FB:2D:B0:2A:F6:BF:03:FD:E8:7C:4B:2F:9B | 
| mozillacert43.pem | 18 giugno 2018 | F9:CD:0E:2C:DA:76:24:C1:8F:BD:F0:F0:AB:B6:45:B8:F7:FE:D5:7A | 
| mozillacert101.pem | 18 giugno 2018 | 99:A6:9B:E6:1A:FE:88:6B:4D:2B:82:00:7C:B8:54:FC:31:7E:15:39 | 
| mozillacert35.pem | 18 giugno 2018 | 2A:C8:D5:8B:57:CE:BF:2F:49:AF:F2:FC:76:8F:51:14:62:90:7A:41 | 
| globalsignr2ca | 21 aprile 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| mozillacert27.pem | 18 giugno 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| affirmtrustpremium | 18 giugno 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert19.pem | 18 giugno 2018 | B4:35:D4:E1:11:9D:1C:66:90:A7:49:EB:B3:94:BD:63:7B:A7:82:B7 | 
| mozillacert97.pem | 18 giugno 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| netlockaranyclassgoldfotanusitvany | 18 giugno 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| mozillacert89.pem | 18 giugno 2018 | C8:EC:8C:87:92:69:CB:4B:AB:39:E9:8D:7E:57:67:F3:14:95:73:9D | 
| verisignroot.pem | 18 giugno 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| mozillacert147.pem | 18 giugno 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| aolrootca2 | 21 aprile 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| cia-crt-g3-01-ca | 23 novembre 2016 | 2B:EE:2C:BA:A3:1D:B5:FE:60:40:41:95:08:ED:46:82:39:4D:ED:E2 | 
| aolrootca1 | 21 aprile 2018 | 39:21:C1:15:C1:5D:0E:CA:5C:CB:5B:C4:F0:7D:21:D8:05:0B:56:6A | 
| verisignc3g1.pem | 18 giugno 2018 | A1:DB:63:93:91:6F:17:E4:18:55:09:40:04:15:C7:02:40:B0:AE:6B | 
| mozillacert139.pem | 18 giugno 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| soneraclass2rootca | 18 giugno 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| swisssignsilverg2ca | 21 aprile 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| thawteprimaryrootca | 18 giugno 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| gdcatrustauthr5root | 18 giugno 2018 | 0F:36:38:5B:81:1A:25:C3:9B:31:4E:83:CA:E9:34:66:70:CC:74:B4 | 
| trustcenterclass4caii | 21 aprile 2018 | A6:9A:91:FD:05:7F:13:6A:42:63:0B:B1:76:0D:2D:51:12:0C:16:50 | 
| usertrustrsacertificationauthority | 18 giugno 2018 | 2B:8F:1B:57:33:0D:BB:A2:D0:7A:6C:51:F7:0E:E9:0D:DA:B9:AD:8E | 
| digicertassuredidrootg3 | 18 giugno 2018 | F5:17:A2:4F:9A:48:C6:C9:F8:A2:00:26:9F:DC:0F:48:2C:AB:30:89 | 
| digicertassuredidrootg2 | 18 giugno 2018 | A1:4B:48:D9:43:EE:0A:0E:40:90:4F:3C:E0:A4:C0:91:93:51:5D:3F | 
| mozillacert50.pem | 18 giugno 2018 | 8C:96:BA:EB:DD:2B:07:07:48:EE:30:32:66:A0:F3:98:6E:7C:AE:58 | 
| mozillacert42.pem | 18 giugno 2018 | 85:A4:08:C0:9C:19:3E:5D:51:58:7D:CD:D6:13:30:FD:8C:DE:37:BF | 
| mozillacert100.pem | 18 giugno 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| mozillacert34.pem | 18 giugno 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| affirmtrustcommercialca | 21 aprile 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert26.pem | 18 giugno 2018 | 87:82:C6:C3:04:35:3B:CF:D2:96:92:D2:59:3E:7D:44:D9:34:FF:11 | 
| globalsigneccrootcar5 | 18 giugno 2018 | 1F:24:C6:30:CD:A4:18:EF:20:69:FF:AD:4F:DD:5F:46:3A:1B:69:AA | 
| globalsigneccrootcar4 | 18 giugno 2018 | 69:69:56:2E:40:80:F4:24:A1:E7:19:9F:14:BA:F3:EE:58:AB:6A:BB | 
| buypassclass3rootca | 18 giugno 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert18.pem | 18 giugno 2018 | 79:98:A3:08:E1:4D:65:85:E6:C2:1E:15:3A:71:9F:BA:5A:D3:4A:D9 | 
| mozillacert96.pem | 18 giugno 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| verisignc2g6.pem | 18 giugno 2018 | 40:B3:31:A0:E9:BF:E8:55:BC:39:93:CA:70:4F:4E:C2:51:D4:1D:8F | 
| secomvalicertclass1ca | 21 aprile 2018 | E5:DF:74:3C:B6:01:C4:9B:98:43:DC:AB:8C:E8:6A:81:10:9F:E4:8E | 
| mozillacert88.pem | 18 giugno 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| accvraiz1 | 18 giugno 2018 | 93:05:7A:88:15:C6:4F:CE:88:2F:FA:91:16:52:28:78:BC:53:64:17 | 
| mozillacert146.pem | 18 giugno 2018 | 21:FC:BD:8E:7F:6C:AF:05:1B:D1:B3:43:EC:A8:E7:61:47:F2:0F:8A | 
| mozillacert138.pem | 18 giugno 2018 | E1:9F:E3:0E:8B:84:60:9E:80:9B:17:0D:72:A8:C5:BA:6E:14:09:BD | 
| verisignclass3g2ca | 21 aprile 2018 | 85:37:1C:A6:E5:50:14:3D:CE:28:03:47:1B:DE:3A:09:E8:F8:77:0F | 
| dtrustrootclass3ca2ev2009 | 18 giugno 2018 | 96:C9:1B:0B:95:B4:10:98:42:FA:D0:D8:22:79:FE:60:FA:B9:16:83 | 
| xrampglobalca | 21 aprile 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| mozillacert9.pem | 18 giugno 2018 | F4:8B:11:BF:DE:AB:BE:94:54:20:71:E6:41:DE:6B:BE:88:2B:40:B9 | 
| verisignuniversalrootcertificationauthority | 18 giugno 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| tubitakkamusmsslkoksertifikasisurum1 | 18 giugno 2018 | 31:43:64:9B:EC:CE:27:EC:ED:3A:3F:0B:8F:0D:E4:E8:91:DD:EE:CA | 
| mozillacert41.pem | 18 giugno 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| mozillacert33.pem | 18 giugno 2018 | FE:B8:C4:32:DC:F9:76:9A:CE:AE:3D:D8:90:8F:FD:28:86:65:64:7D | 
| mozillacert25.pem | 18 giugno 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| mozillacert17.pem | 18 giugno 2018 | 40:54:DA:6F:1C:3F:40:74:AC:ED:0F:EC:CD:DB:79:D1:53:FB:90:1D | 
| mozillacert95.pem | 18 giugno 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| affirmtrustpremiumeccca | 21 aprile 2018 | B8:23:6B:00:2F:1D:16:86:53:01:55:6C:11:A4:37:CA:EB:FF:C3:BB | 
| mozillacert87.pem | 18 giugno 2018 | 5F:3B:8C:F2:F8:10:B3:7D:78:B4:CE:EC:19:19:C3:73:34:B9:C7:74 | 
| mozillacert145.pem | 18 giugno 2018 | 10:1D:FA:3F:D5:0B:CB:BB:9B:B5:60:0C:19:55:A4:1A:F4:73:3A:04 | 
| mozillacert79.pem | 18 giugno 2018 | D8:A6:33:2C:E0:03:6F:B1:85:F6:63:4F:7D:6A:06:65:26:32:28:27 | 
| mozillacert137.pem | 18 giugno 2018 | 4A:65:D5:F4:1D:EF:39:B8:B8:90:4A:4A:D3:64:81:33:CF:C7:A1:D1 | 
| digicertassuredidrootca | 18 giugno 2018 | 05:63:B8:63:0D:62:D7:5A:BB:C8:AB:1E:4B:DF:B5:A8:99:B2:4D:43 | 
| addtrustqualifiedca | 21 aprile 2018 | 4D:23:78:EC:91:95:39:B5:00:7F:75:8F:03:3B:21:1E:C5:4D:8B:CF | 
| mozillacert129.pem | 18 giugno 2018 | E6:21:F3:35:43:79:05:9A:4B:68:30:9D:8A:2F:74:22:15:87:EC:79 | 
| verisignclass2g2ca | 21 aprile 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| baltimorecodesigningca | 21 aprile 2018 | 30:46:D8:C8:88:FF:69:30:C3:4A:FC:CD:49:27:08:7C:60:56:7B:0D | 
| luxtrustglobalroot2 | 18 giugno 2018 | 1E:0E:56:19:0A:D1:8B:25:98:B2:04:44:FF:66:8A:04:17:99:5F:3F | 
| visaecommerceroot | 18 giugno 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| oistewisekeyglobalrootgbca | 18 giugno 2018 | 0F:F9:40:76:18:D3:D7:6A:4B:98:F0:A8:35:9E:0C:FD:27:AC:CC:ED | 
| mozillacert8.pem | 18 giugno 2018 | 3E:2B:F7:F2:03:1B:96:F3:8C:E6:C4:D8:A8:5D:3E:2D:58:47:6A:0F | 
| comodocertificationauthority | 18 giugno 2018 | 66:31:BF:9E:F7:4F:9E:B6:C9:D5:A6:0C:BA:6A:BE:D1:F7:BD:EF:7B | 
| cia-crt-g3-02-ca | 23 novembre 2016 | 96:4A:BB:A7:BD:DA:FC:97:34:C0:0A:2D:F0:05:98:F7:E6:C6:6F:09 | 
| verisignc1g6.pem | 18 giugno 2018 | 51:7F:61:1E:29:91:6B:53:82:FB:72:E7:44:D9:8D:C3:CC:53:6D:64 | 
| trustcenterclass2caii | 21 aprile 2018 | AE:50:83:ED:7C:F4:5C:BC:8F:61:C6:21:FE:68:5D:79:42:21:15:6E | 
| quovadisrootca1g3 | 18 giugno 2018 | 1B:8E:EA:57:96:29:1A:C9:39:EA:B8:0A:81:1A:73:73:C0:93:79:67 | 
| mozillacert40.pem | 18 giugno 2018 | 80:25:EF:F4:6E:70:C8:D4:72:24:65:84:FE:40:3B:8A:8D:6A:DB:F5 | 
| cadisigrootr2 | 18 giugno 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| cadisigrootr1 | 18 giugno 2018 | 8E:1C:74:F8:A6:20:B9:E5:8A:F4:61:FA:EC:2B:47:56:51:1A:52:C6 | 
| mozillacert32.pem | 18 giugno 2018 | 60:D6:89:74:B5:C2:65:9E:8A:0F:C1:88:7C:88:D2:46:69:1B:18:2C | 
| utndatacorpsgcca | 21 aprile 2018 | 58:11:9F:0E:12:82:87:EA:50:FD:D9:87:45:6F:4F:78:DC:FA:D6:D4 | 
| mozillacert24.pem | 18 giugno 2018 | 59:AF:82:79:91:86:C7:B4:75:07:CB:CF:03:57:46:EB:04:DD:B7:16 | 
| addtrustclass1ca | 21 aprile 2018 | CC:AB:0E:A0:4C:23:01:D6:69:7B:DD:37:9F:CD:12:EB:24:E3:94:9D | 
| mozillacert16.pem | 18 giugno 2018 | DA:C9:02:4F:54:D8:F6:DF:94:93:5F:B1:73:26:38:CA:6A:D7:7C:13 | 
| affirmtrustnetworkingca | 21 aprile 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert94.pem | 18 giugno 2018 | 49:0A:75:74:DE:87:0A:47:FE:58:EE:F6:C7:6B:EB:C6:0B:12:40:99 | 
| mozillacert86.pem | 18 giugno 2018 | 74:2C:31:92:E6:07:E4:24:EB:45:49:54:2B:E1:BB:C5:3E:61:74:E2 | 
| mozillacert144.pem | 18 giugno 2018 | 37:F7:6D:E6:07:7C:90:C5:B1:3E:93:1A:B7:41:10:B4:F2:E4:9A:27 | 
| mozillacert78.pem | 18 giugno 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| mozillacert136.pem | 18 giugno 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert128.pem | 18 giugno 2018 | A9:E9:78:08:14:37:58:88:F2:05:19:B0:6D:2B:0D:2B:60:16:90:7D | 
| verisignclass1g2ca | 21 aprile 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| hellenicacademicandresearchinstitutionsrootca2015 | 18 giugno 2018 | 01:0C:06:95:A6:98:19:14:FF:BF:5F:C6:B0:B6:95:EA:29:E9:12:A6 | 
| soneraclass1ca | 21 aprile 2018 | 07:47:22:01:99:CE:74:B9:7C:B0:3D:79:B2:64:A2:C8:55:E9:33:FF | 
| hellenicacademicandresearchinstitutionsrootca2011 | 18 giugno 2018 | FE:45:65:9B:79:03:5B:98:A1:61:B5:51:2E:AC:DA:58:09:48:22:4D | 
| certumtrustednetworkca2 | 18 giugno 2018 | D3:DD:48:3E:2B:BF:4C:05:E8:AF:10:F5:FA:76:26:CF:D3:DC:30:92 | 
| equifaxsecureca | 21 aprile 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| thawteserverca | 21 aprile 2018 | 9F:AD:91:A6:CE:6A:C6:C5:00:47:C4:4E:C9:D4:A5:0D:92:D8:49:79 | 
| mozillacert7.pem | 18 giugno 2018 | AD:7E:1C:28:B0:64:EF:8F:60:03:40:20:14:C3:D0:E3:37:0E:B5:8A | 
| affirmtrustnetworking | 18 giugno 2018 | 29:36:21:02:8B:20:ED:02:F5:66:C5:32:D1:D6:ED:90:9F:45:00:2F | 
| deprecateditsecca | 27 gennaio 2012 | 12:12:0B:03:0E:15:14:54:F4:DD:B3:F5:DE:13:6E:83:5A:29:72:9D | 
| globalsignrootcar3 | 18 giugno 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| globalsignrootcar2 | 18 giugno 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| quovadisrootca | 18 giugno 2018 | DE:3F:40:BD:50:93:D3:9B:6C:60:F6:DA:BC:07:62:01:00:89:76:C9 | 
| mozillacert31.pem | 18 giugno 2018 | 9F:74:4E:9F:2B:4D:BA:EC:0F:31:2C:50:B6:56:3B:8E:2D:93:C3:11 | 
| entrustrootcertificationauthority | 18 giugno 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert23.pem | 18 giugno 2018 | 91:C6:D6:EE:3E:8A:C8:63:84:E5:48:C2:99:29:5C:75:6C:81:7B:81 | 
| mozillacert15.pem | 18 giugno 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| verisignc2g3.pem | 18 giugno 2018 | 61:EF:43:D7:7F:CA:D4:61:51:BC:98:E0:C3:59:12:AF:9F:EB:63:11 | 
| mozillacert93.pem | 18 giugno 2018 | 31:F1:FD:68:22:63:20:EE:C6:3B:3F:9D:EA:4A:3E:53:7C:7C:39:17 | 
| mozillacert151.pem | 18 giugno 2018 | AC:ED:5F:65:53:FD:25:CE:01:5F:1F:7A:48:3B:6A:74:9F:61:78:C6 | 
| mozillacert85.pem | 18 giugno 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| certplusclass2primaryca | 18 giugno 2018 | 74:20:74:41:72:9C:DD:92:EC:79:31:D8:23:10:8D:C2:81:92:E2:BB | 
| mozillacert143.pem | 18 giugno 2018 | 36:B1:2B:49:F9:81:9E:D7:4C:9E:BC:38:0F:C6:56:8F:5D:AC:B2:F7 | 
| mozillacert77.pem | 18 giugno 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| mozillacert135.pem | 18 giugno 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert69.pem | 18 giugno 2018 | 2F:78:3D:25:52:18:A7:4A:65:39:71:B5:2C:A2:9C:45:15:6F:E9:19 | 
| mozillacert127.pem | 18 giugno 2018 | DE:28:F4:A4:FF:E5:B9:2F:A3:C5:03:D1:A3:49:A7:F9:96:2A:82:12 | 
| mozillacert119.pem | 18 giugno 2018 | 75:E0:AB:B6:13:85:12:27:1C:04:F8:5F:DD:DE:38:E4:B7:24:2E:FE | 
| geotrustprimarycag3 | 21 aprile 2018 | 03:9E:ED:B8:0B:E7:A0:3C:69:53:89:3B:20:D2:D9:32:3A:4C:2A:FD | 
| identrustpublicsectorrootca1 | 18 giugno 2018 | BA:29:41:60:77:98:3F:F4:F3:EF:F2:31:05:3B:2E:EA:6D:4D:45:FD | 
| geotrustprimarycag2 | 21 aprile 2018 | 8D:17:84:D5:37:F3:03:7D:EC:70:FE:57:8B:51:9A:99:E6:10:D7:B0 | 
| trustcorrootcertca2 | 18 giugno 2018 | B8:BE:6D:CB:56:F1:55:B9:63:D4:12:CA:4E:06:34:C7:94:B2:1C:C0 | 
| mozillacert6.pem | 18 giugno 2018 | 27:96:BA:E6:3F:18:01:E2:77:26:1B:A0:D7:77:70:02:8F:20:EE:E4 | 
| trustcorrootcertca1 | 18 giugno 2018 | FF:BD:CD:E7:82:C8:43:5E:3C:6F:26:86:5C:CA:A8:3A:45:5B:C3:0A | 
| networksolutionscertificateauthority | 18 giugno 2018 | 74:F8:A3:C3:EF:E7:B3:90:06:4B:83:90:3C:21:64:60:20:E5:DF:CE | 
| twcarootcertificationauthority | 18 giugno 2018 | CF:9E:87:6D:D3:EB:FC:42:26:97:A3:B5:A3:7A:A0:76:A9:06:23:48 | 
| addtrustexternalca | 21 aprile 2018 | 02:FA:F3:E2:91:43:54:68:60:78:57:69:4D:F5:E4:5B:68:85:18:68 | 
| verisignclass3g5ca | 21 aprile 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| autoridaddecertificacionfirmaprofesionalcifa62634068 | 18 giugno 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| hellenicacademicandresearchinstitutionseccrootca2015 | 18 giugno 2018 | 9F:F1:71:8D:92:D5:9A:F3:7D:74:97:B4:BC:6F:84:68:0B:BA:B6:66 | 
| verisigntsaca | 21 aprile 2018 | 20:CE:B1:F0:F5:1C:0E:19:A9:F3:8D:B1:AA:8E:03:8C:AA:7A:C7:01 | 
| utnuserfirsthardwareca | 21 aprile 2018 | 04:83:ED:33:99:AC:36:08:05:87:22:ED:BC:5E:46:00:E3:BE:F9:D7 | 
| identrustcommercialrootca1 | 18 giugno 2018 | DF:71:7E:AA:4A:D9:4E:C9:55:84:99:60:2D:48:DE:5F:BC:F0:3A:25 | 
| dtrustrootclass3ca22009 | 18 giugno 2018 | 58:E8:AB:B0:36:15:33:FB:80:F7:9B:1B:6D:29:D3:FF:8D:5F:00:F0 | 
| epkirootcertificationauthority | 18 giugno 2018 | 67:65:0D:F1:7E:8E:7E:5B:82:40:A4:F4:56:4B:CF:E2:3D:69:C6:F0 | 
| mozillacert30.pem | 18 giugno 2018 | E7:B4:F6:9D:61:EC:90:69:DB:7E:90:A7:40:1A:3C:F4:7D:4F:E8:EE | 
| teliasonerarootcav1 | 18 giugno 2018 | 43:13:BB:96:F1:D5:86:9B:C1:4E:6A:92:F6:CF:F6:34:69:87:82:37 | 
| buypassclass3ca | 21 aprile 2018 | DA:FA:F7:FA:66:84:EC:06:8F:14:50:BD:C7:C2:81:A5:BC:A9:64:57 | 
| mozillacert22.pem | 18 giugno 2018 | 32:3C:11:8E:1B:F7:B8:B6:52:54:E2:E2:10:0D:D6:02:90:37:F0:96 | 
| mozillacert14.pem | 18 giugno 2018 | 5F:B7:EE:06:33:E2:59:DB:AD:0C:4C:9A:E6:D3:8F:1A:61:C7:DC:25 | 
| verisignc2g2.pem | 18 giugno 2018 | B3:EA:C4:47:76:C9:C8:1C:EA:F2:9D:95:B6:CC:A0:08:1B:67:EC:9D | 
| certumca | 21 aprile 2018 | 62:52:DC:40:F7:11:43:A2:2F:DE:9E:F7:34:8E:06:42:51:B1:81:18 | 
| mozillacert92.pem | 18 giugno 2018 | A3:F1:33:3F:E2:42:BF:CF:C5:D1:4E:8F:39:42:98:40:68:10:D1:A0 | 
| mozillacert150.pem | 18 giugno 2018 | 33:9B:6B:14:50:24:9B:55:7A:01:87:72:84:D9:E0:2F:C3:D2:D8:E9 | 
| mozillacert84.pem | 18 giugno 2018 | D3:C0:63:F2:19:ED:07:3E:34:AD:5D:75:0B:32:76:29:FF:D5:9A:F2 | 
| ttelesecglobalrootclass3 | 18 giugno 2018 | 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1 | 
| globalsignrootca | 18 giugno 2018 | B1:BC:96:8B:D4:F4:9D:62:2A:A8:9A:81:F2:15:01:52:A4:1D:82:9C | 
| ttelesecglobalrootclass2 | 18 giugno 2018 | 59:0D:2D:7D:88:4F:40:2E:61:7E:A5:62:32:17:65:CF:17:D8:94:E9 | 
| mozillacert142.pem | 18 giugno 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| mozillacert76.pem | 18 giugno 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| mozillacert134.pem | 18 giugno 2018 | 70:17:9B:86:8C:00:A4:FA:60:91:52:22:3F:9F:3E:32:BD:E0:05:62 | 
| mozillacert68.pem | 18 giugno 2018 | AE:C5:FB:3F:C8:E1:BF:C4:E5:4F:03:07:5A:9A:E8:00:B7:F7:B6:FA | 
| etugracertificationauthority | 18 giugno 2018 | 51:C6:E7:08:49:06:6E:F3:92:D4:5C:A0:0D:6D:A3:62:8F:C3:52:39 | 
| mozillacert126.pem | 18 giugno 2018 | 25:01:90:19:CF:FB:D9:99:1C:B7:68:25:74:8D:94:5F:30:93:95:42 | 
| keynectisrootca | 21 aprile 2018 | 9C:61:5C:4D:4D:85:10:3A:53:26:C2:4D:BA:EA:E4:A2:D2:D5:CC:97 | 
| mozillacert118.pem | 18 giugno 2018 | 7E:78:4A:10:1C:82:65:CC:2D:E1:F1:6D:47:B4:40:CA:D9:0A:19:45 | 
| quovadisrootca3 | 18 giugno 2018 | 1F:49:14:F7:D8:74:95:1D:DD:AE:02:C0:BE:FD:3A:2D:82:75:51:85 | 
| quovadisrootca2 | 18 giugno 2018 | CA:3A:FB:CF:12:40:36:4B:44:B2:16:20:88:80:48:39:19:93:7C:F7 | 
| mozillacert5.pem | 18 giugno 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| verisignc1g3.pem | 18 giugno 2018 | 20:42:85:DC:F7:EB:76:41:95:57:8E:13:6B:D4:B7:D1:E9:8E:46:A5 | 
| cybertrustglobalroot | 18 giugno 2018 | 5F:43:E5:B1:BF:F8:78:8C:AC:1C:C7:CA:4A:9A:C6:22:2B:CC:34:C6 | 
| amzninternalinfoseccag3 | 27 febbraio 2015 | B9:B1:CA:38:F7:BF:9C:D2:D4:95:E7:B6:5E:75:32:9B:A8:78:2E:F6 | 
| starfieldrootcertificateauthorityg2 | 18 giugno 2018 | B5:1C:06:7C:EE:2B:0C:3D:F8:55:AB:2D:92:F4:FE:39:D4:E7:0F:0E | 
| entrust2048ca | 21 aprile 2018 | 50:30:06:09:1D:97:D4:F5:AE:39:F7:CB:E7:92:7D:7D:65:2D:34:31 | 
| swisssignsilvercag2 | 18 giugno 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| affirmtrustcommercial | 18 giugno 2018 | F9:B5:B6:32:45:5F:9C:BE:EC:57:5F:80:DC:E9:6E:2C:C7:B2:78:B7 | 
| certinomisrootca | 18 giugno 2018 | 9D:70:BB:01:A5:A4:A0:18:11:2E:F7:1C:01:B9:32:C5:34:E7:88:A8 | 
| xrampglobalcaroot | 18 giugno 2018 | B8:01:86:D1:EB:9C:86:A5:41:04:CF:30:54:F3:4C:52:B7:E5:58:C6 | 
| secureglobalca | 18 giugno 2018 | 3A:44:73:5A:E5:81:90:1F:24:86:61:46:1E:3B:9C:C4:5F:F5:3A:1B | 
| swisssigngoldg2ca | 21 aprile 2018 | D8:C5:38:8A:B7:30:1B:1B:6E:D4:7A:E6:45:25:3A:6F:9F:1A:27:61 | 
| mozillacert21.pem | 18 giugno 2018 | 9B:AA:E5:9F:56:EE:21:CB:43:5A:BE:25:93:DF:A7:F0:40:D1:1D:CB | 
| mozillacert13.pem | 18 giugno 2018 | 06:08:3F:59:3F:15:A1:04:A0:69:A4:6B:A9:03:D0:06:B7:97:09:91 | 
| verisignc2g1.pem | 18 giugno 2018 | 67:82:AA:E0:ED:EE:E2:1A:58:39:D3:C0:CD:14:68:0A:4F:60:14:2A | 
| mozillacert91.pem | 18 giugno 2018 | 3B:C0:38:0B:33:C3:F6:A6:0C:86:15:22:93:D9:DF:F5:4B:81:C0:04 | 
| oistewisekeyglobalrootgaca | 18 giugno 2018 | 59:22:A1:E1:5A:EA:16:35:21:F8:98:39:6A:46:46:B0:44:1B:0F:A9 | 
| mozillacert83.pem | 18 giugno 2018 | A0:73:E5:C5:BD:43:61:0D:86:4C:21:13:0A:85:58:57:CC:9C:EA:46 | 
| entrustevca | 21 aprile 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert141.pem | 18 giugno 2018 | 31:7A:2A:D0:7F:2B:33:5E:F5:A1:C3:4E:4B:57:E8:B7:D8:F1:FC:A6 | 
| mozillacert75.pem | 18 giugno 2018 | D2:32:09:AD:23:D3:14:23:21:74:E4:0D:7F:9D:62:13:97:86:63:3A | 
| mozillacert133.pem | 18 giugno 2018 | 85:B5:FF:67:9B:0C:79:96:1F:C8:6E:44:22:00:46:13:DB:17:92:84 | 
| mozillacert67.pem | 18 giugno 2018 | D6:9B:56:11:48:F0:1C:77:C5:45:78:C1:09:26:DF:5B:85:69:76:AD | 
| mozillacert125.pem | 18 giugno 2018 | B3:1E:B1:B7:40:E3:6C:84:02:DA:DC:37:D4:4D:F5:D4:67:49:52:F9 | 
| mozillacert59.pem | 18 giugno 2018 | 36:79:CA:35:66:87:72:30:4D:30:A5:FB:87:3B:0F:A7:7B:B7:0D:54 | 
| thawtepremiumserverca | 21 aprile 2018 | E0:AB:05:94:20:72:54:93:05:60:62:02:36:70:F7:CD:2E:FC:66:66 | 
| mozillacert117.pem | 18 giugno 2018 | D4:DE:20:D0:5E:66:FC:53:FE:1A:50:88:2C:78:DB:28:52:CA:E4:74 | 
| utnuserfirstclientauthemailca | 21 aprile 2018 | B1:72:B1:A5:6D:95:F9:1F:E5:02:87:E1:4D:37:EA:6A:44:63:76:8A | 
| entrustrootcag2 | 21 aprile 2018 | 8C:F4:27:FD:79:0C:3A:D1:66:06:8D:E8:1E:57:EF:BB:93:22:72:D4 | 
| mozillacert109.pem | 18 giugno 2018 | B5:61:EB:EA:A4:DE:E4:25:4B:69:1A:98:A5:57:47:C2:34:C7:D9:71 | 
| digicerttrustedrootg4 | 18 giugno 2018 | DD:FB:16:CD:49:31:C9:73:A2:03:7D:3F:C8:3A:4D:7D:77:5D:05:E4 | 
| gdroot-g2.pem | 18 giugno 2018 | 47:BE:AB:C9:22:EA:E8:0E:78:78:34:62:A7:9F:45:C2:54:FD:E6:8B | 
| comodoaaaservicesroot | 18 giugno 2018 | D1:EB:23:A4:6D:17:D6:8F:D9:25:64:C2:F1:F1:60:17:64:D8:E3:49 | 
| mozillacert4.pem | 18 giugno 2018 | E3:92:51:2F:0A:CF:F5:05:DF:F6:DE:06:7F:75:37:E1:65:EA:57:4B | 
| verisignclass3publicprimarycertificationauthorityg5 | 18 giugno 2018 | 4E:B6:D5:78:49:9B:1C:CF:5F:58:1E:AD:56:BE:3D:9B:67:44:A5:E5 | 
| chambersofcommerceroot2008 | 18 giugno 2018 | 78:6A:74:AC:76:AB:14:7F:9C:6A:30:50:BA:9E:A8:7E:FE:9A:CE:3C | 
| verisignclass3publicprimarycertificationauthorityg4 | 18 giugno 2018 | 22:D5:D8:DF:8F:02:31:D1:8D:F7:9D:B7:CF:8A:2D:64:C9:3F:6C:3A | 
| verisignclass3publicprimarycertificationauthorityg3 | 18 giugno 2018 | 13:2D:0D:45:53:4B:69:97:CD:B2:D5:C3:39:E2:55:76:60:9B:5C:C6 | 
| thawtepersonalfreemailca | 21 aprile 2018 | E6:18:83:AE:84:CA:C1:C1:CD:52:AD:E8:E9:25:2B:45:A6:4F:B7:E2 | 
| verisignc1g2.pem | 18 giugno 2018 | 27:3E:E1:24:57:FD:C4:F9:0C:55:E8:2B:56:16:7F:62:F5:32:E5:47 | 
| gtecybertrustglobalca | 21 aprile 2018 | 97:81:79:50:D8:1C:96:70:CC:34:D8:09:CF:79:44:31:36:7E:F4:74 | 
| trustcenteruniversalcai | 21 aprile 2018 | 6B:2F:34:AD:89:58:BE:62:FD:B0:6B:5C:CE:BB:9D:D9:4F:4E:39:F3 | 
| camerfirmachamberscommerceca | 21 aprile 2018 | 6E:3A:55:A4:19:0C:19:5C:93:84:3C:C0:DB:72:2E:31:30:61:F0:B1 | 
| verisignclass1ca | 21 aprile 2018 | CE:6A:64:A3:09:E4:2F:BB:D9:85:1C:45:3E:64:09:EA:E8:7D:60:F1 | 

# AWS AppSync log delle modifiche del modello di mappatura del resolver
<a name="resolver-mapping-template-changelog"></a>

**Nota**  
Ora supportiamo principalmente il runtime APPSYNC\$1JS e la relativa documentazione. [Prendi in considerazione l'utilizzo del runtime APPSYNC\$1JS e delle relative guide qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html)

I modelli di mappatura del resolver e della funzione prevedono versioni multiple. La versione del modello di mappatura, ad esempio), impone quanto segue`2018-05-29`:
+ La forma prevista della configurazione della richiesta di origine dati fornita dal modello di richiesta
+ Il comportamento di esecuzione del modello di mappatura della richiesta e del modello di mappatura della risposta

Le versioni sono rappresentate utilizzando il YYYY-MM-DD formato, una data successiva corrisponde a una versione più recente. Questa pagina elenca le differenze tra le versioni dei modelli di mappatura attualmente supportate in AWS AppSync.

**Topics**
+ [Disponibilità delle operazioni dell'origine dati per matrice di versione](#aws-appsync-resolver-mapping-template-operation-availability-per-version)
+ [Modifica della versione su un modello di mappatura del resolver di unità.](#changing-the-version-on-a-unit-resolver-mapping-template)
+ [Modifica della versione su una funzione](#changing-the-version-on-a-function)
+ [2018-05-29](#aws-appsync-resolver-mapping-template-version-2018-05-29)
+ [2017-02-28](#aws-appsync-resolver-mapping-template-version-2017-02-28)

## Disponibilità delle operazioni dell'origine dati per matrice di versione
<a name="aws-appsync-resolver-mapping-template-operation-availability-per-version"></a>


| Operazione/versione supportata | 2017-02-28 | 2018-05-29 | 
| --- | --- | --- | 
|  AWS Lambda Invoca  |  Sì   |  Sì  | 
|  AWS Lambda BatchInvoke  |  Sì  |  Sì  | 
|  Nessuna origine dati  |  Sì   |  Sì  | 
|  Amazon OpenSearch GET  |  Sì   |  Sì  | 
|  Amazon OpenSearch POST  |  Sì   |  Sì  | 
|  Amazon OpenSearch PUT  |  Sì   |  Sì  | 
|  Amazon OpenSearch ELIMINA  |  Sì   |  Sì  | 
|  Amazon OpenSearch GET  |  Sì   |  Sì  | 
|  DynamoDB GetItem  |  Sì   |  Sì  | 
|  Scan di DynamoDB  |  Sì   |  Sì  | 
|  Query di DynamoDB  |  Sì   |  Sì  | 
|  DynamoDB DeleteItem  |  Sì   |  Sì  | 
|  DynamoDB PutItem  |  Sì   |  Sì  | 
|  DynamoDB BatchGetItem  |  No  |  Sì  | 
|  DynamoDB BatchPutItem  |  No  |  Sì  | 
|  DynamoDB BatchDeleteItem  |  No  |  Sì  | 
|  HTTP  |  No  |  Sì  | 
|  Amazon RDS  |  No  |  Sì  | 

 **Nota**: solo la versione **2018-05-29** è attualmente supportata nelle funzioni.

## Modifica della versione su un modello di mappatura del resolver di unità.
<a name="changing-the-version-on-a-unit-resolver-mapping-template"></a>

Per i resolver di unità, la versione viene specificata come parte del corpo del modello di mappatura della richiesta. Per aggiornare la versione, è sufficiente aggiornare il campo `version` alla nuova versione.

Ad esempio, per aggiornare la versione del modello: AWS Lambda 

```
{
    "version": "2017-02-28",
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments": $utils.toJson($context.arguments)
    }
}
```

È necessario aggiornare il campo dalla versione `2017-02-28` alla `2018-05-29` nel seguente modo:

```
{
    "version": "2018-05-29", ## Note the version
    "operation": "Invoke",
    "payload": {
        "field": "getPost",
        "arguments": $utils.toJson($context.arguments)
    }
}
```

## Modifica della versione su una funzione
<a name="changing-the-version-on-a-function"></a>

Per le funzioni, la versione è specificata come campo `functionVersion` nell'oggetto della funzione. Per aggiornare la versione, basta aggiornare la `functionVersion`. *Nota:* al momento, solo la versione `2018-05-29` è supportata per la funzione.

Di seguito è riportato un esempio di un comando dell'interfaccia a riga di comando per aggiornare la versione di una funzione esistente:

```
aws appsync update-function \
--api-id REPLACE_WITH_API_ID \
--function-id REPLACE_WITH_FUNCTION_ID \
--data-source-name "PostTable" \
--function-version "2018-05-29" \
--request-mapping-template "{...}" \
--response-mapping-template "\$util.toJson(\$ctx.result)"
```

 **Nota:** si consiglia di omettere il campo della versione dal modello di mappatura della richiesta di funzione, perché non verrà rispettato. Se non specifichi una versione all'interno del modello di mappatura della richiesta di funzione, il valore della versione verrà sostituito da quello nel campo `functionVersion`.

## 2018-05-29
<a name="aws-appsync-resolver-mapping-template-version-2018-05-29"></a>

### Modifica del comportamento
<a name="behavior-change"></a>
+ Se il risultato dell'invocazione dell'origine dati è `null`, viene eseguito il modello di mappatura della risposta.
+ Se l'invocazione dell'origine dati genera un errore, tocca a te gestirlo, il risultato valutato del modello di mappatura della risposta sarà **sempre** inserito all'interno del blocco di `data` della risposta GraphQL.

### Ragionamento
<a name="reasoning"></a>
+ Un risultato `null` di un'invocazione ha un significato e in alcun casi d'uso è preferibile gestire i risultati `null` in modo personalizzato. Ad esempio, un'applicazione potrebbe verificare se esiste un record in una tabella Amazon DynamoDB per eseguire alcuni controlli di autorizzazione. In tal caso, un risultato `null` dell'invocazione vorrebbe dire che l'utente potrebbe non essere autorizzato. L'esecuzione del modello di mappatura della risposta offre ora la possibilità di generare un errore non autorizzato. Questo comportamento offre un maggiore controllo al progettista API.

Dato il seguente modello di mappatura della risposta:

```
$util.toJson($ctx.result)
```

In passato, nella versione `2017-02-28`, se `$ctx.result` tornava null, il modello di mappatura della risposta non veniva eseguito. Con la versione `2018-05-29`, ora possiamo gestire questo scenario. Ad esempio, è possibile scegliere di generare un errore di autorizzazione nel modo seguente:

```
# throw an unauthorized error if the result is null
#if ( $util.isNull($ctx.result) )
    $util.unauthorized()
#end
$util.toJson($ctx.result)
```

 **Nota:** a volte gli errori restituiti da un'origine dati non sono fatali né previsti, ecco perché il modello di mappatura della risposta deve avere la flessibilità di gestire l'errore di invocazione e decidere se ignorarlo, rigenerarlo o generarne un altro.

Dato il seguente modello di mappatura della risposta:

```
$util.toJson($ctx.result)
```

In passato, nella versione `2017-02-28`, in caso di un errore di invocazione, veniva valutato il modello di mappatura della risposta e il risultato veniva inserito automaticamente nel blocco `errors` della risposta GraphQL. Con la versione `2018-05-29`, è ora possibile scegliere cosa fare con l'errore, se rigenerarlo, generarne uno diverso o aggiungere l'errore durante la restituzione dei dati.

### Rigenerare un errore di invocazione
<a name="re-raise-an-invocation-error"></a>

Nel seguente modello di risposta, generiamo lo stesso errore restituito dall'origine dati.

```
#if ( $ctx.error )
    $util.error($ctx.error.message, $ctx.error.type)
#end
$util.toJson($ctx.result)
```

Nel caso di un errore di invocazione (ad esempio se è presente `$ctx.error`) la risposta è simile alla seguente:

```
{
    "data": {
        "getPost": null
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "DynamoDB:ConditionalCheckFailedException",
            "message": "Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

### Generare un errore diverso
<a name="raise-a-different-error"></a>

Nel seguente modello di risposta, generiamo lo stesso errore personalizzato dopo aver elaborato l'errore restituito dall'origine dati.

```
#if ( $ctx.error )
    #if ( $ctx.error.type.equals("ConditionalCheckFailedException") )
        ## we choose here to change the type and message of the error for ConditionalCheckFailedExceptions
        $util.error("Error while updating the post, try again. Error: $ctx.error.message", "UpdateError")
    #else
        $util.error($ctx.error.message, $ctx.error.type)
    #end
#end
$util.toJson($ctx.result)
```

Nel caso di un errore di invocazione (ad esempio se è presente `$ctx.error`) la risposta è simile alla seguente:

```
{
    "data": {
        "getPost": null
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "UpdateError",
            "message": "Error while updating the post, try again. Error: Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

### Aggiungere un errore ai dati restituiti
<a name="append-an-error-to-return-data"></a>

Nel seguente modello di risposta, aggiungiamo lo stesso errore restituito dall'origine dati mentre reinseriamo i dati all'interno della risposta. Questo è noto anche come risposta parziale.

```
#if ( $ctx.error )
    $util.appendError($ctx.error.message, $ctx.error.type)
    #set($defaultPost = {id: "1", title: 'default post'})
    $util.toJson($defaultPost)
#else
    $util.toJson($ctx.result)
#end
```

Nel caso di un errore di invocazione (ad esempio se è presente `$ctx.error`) la risposta è simile alla seguente:

```
{
    "data": {
        "getPost": {
            "id": "1",
            "title: "A post"
        }
    },
    "errors": [
        {
            "path": [
                "getPost"
            ],
            "errorType": "ConditionalCheckFailedException",
            "message": "Conditional check failed exception...",
            "locations": [
                {
                    "line": 5,
                    "column": 5
                }
            ]
        }
    ]
}
```

#### Migrazione dalla versione *2017-02-28* alla *2018-05-29*
<a name="migrating-from-2017-02-28-to-2018-05-29"></a>

La migrazione dalla versione **2017-02-28** alla **2018-05-29** è semplice. Modifica il campo della versione nel modello di mappatura della richiesta del resolver o nell'oggetto della versione della funzione. Tuttavia, tieni presente che l'esecuzione della versione **2018-05-29** si comporta in modo diverso dalla **2017-02-28**; le modifiche sono evidenziate [qui](#aws-appsync-resolver-mapping-template-version-2018-05-29).

#### Mantenere lo stesso comportamento di esecuzione dalla versione *2017-02-28* alla *2018-05-29*
<a name="preserving-the-same-execution-behavior-from-2017-02-28-to-2018-05-29"></a>

In alcuni casi, è possibile mantenere lo stesso comportamento di esecuzione della versione **2017-02-28** durante l'esecuzione di un modello che ha la versione **2018-05-29**.

### Esempio: DynamoDB PutItem
<a name="example-dynamodb-putitem"></a>

Dato il seguente modello di richiesta DynamoDB PutItem del **28/02/2017**:

```
{
    "version" : "2017-02-28",
    "operation" : "PutItem",
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    }
}
```

E il seguente modello di risposta:

```
$util.toJson($ctx.result)
```

La migrazione alla versione **2018-05-29** modifica questi modelli nel modo seguente:

```
{
    "version" : "2018-05-29", ## Note the new 2018-05-29 version
    "operation" : "PutItem",
    "key": {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "attributeValues" : {
        "baz" : ... typed value
    },
    "condition" : {
       ...
    }
}
```

E modifica il modello di risposta nel modo seguente:

```
## If there is a datasource invocation error, we choose to raise the same error
## the field data will be set to null.
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type, $ctx.result)
#end

## If the data source invocation is null, we return null.
#if($util.isNull($ctx.result))
  #return
#end

$util.toJson($ctx.result)
```

Ora che hai la responsabilità di gestire gli errori, abbiamo scelto di generare lo stesso errore utilizzando `$util.error()` che è stato restituito da DynamoDB. Puoi adattare questo frammento per convertire il modello di mappatura alla versione **2018-05-29**, ma devi ricordare che se il modello di risposta è diverso dovrai tenere conto delle modifiche al comportamento di esecuzione.

### Esempio: DynamoDB GetItem
<a name="example-dynamodb-getitem"></a>

Dato il seguente modello di richiesta DynamoDB GetItem del **28/02/2017**:

```
{
    "version" : "2017-02-28",
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true
}
```

E il seguente modello di risposta:

```
## map table attribute postId to field Post.id
$util.qr($ctx.result.put("id", $ctx.result.get("postId")))

$util.toJson($ctx.result)
```

La migrazione alla versione **2018-05-29** modifica questi modelli nel modo seguente:

```
{
    "version" : "2018-05-29", ## Note the new 2018-05-29 version
    "operation" : "GetItem",
    "key" : {
        "foo" : ... typed value,
        "bar" : ... typed value
    },
    "consistentRead" : true
}
```

E modifica il modello di risposta nel modo seguente:

```
## If there is a datasource invocation error, we choose to raise the same error
#if($ctx.error)
  $util.error($ctx.error.message, $ctx.error.type)
#end

## If the data source invocation is null, we return null.
#if($util.isNull($ctx.result))
  #return
#end

## map table attribute postId to field Post.id
$util.qr($ctx.result.put("id", $ctx.result.get("postId")))

$util.toJson($ctx.result)
```

Nella versione **2017-02-28**, se l'invocazione dell'origine dati era `null`, cioè non c'era alcuna voce nella tabella DynamoDB che corrispondeva alla nostra chiave, il modello di mappatura della risposta non sarebbe stato eseguito. Questo poteva andare bene nella maggior parte dei casi, ma se prevedevi che `$ctx.result` non fosse `null`, questo scenario deve essere gestito.

## 2017-02-28
<a name="aws-appsync-resolver-mapping-template-version-2017-02-28"></a>

### Caratteristiche
<a name="characteristics"></a>
+ Se il risultato dell'invocazione dell'origine dati è `null`, il modello di mappatura della risposta **non** viene eseguito.
+ Se l'invocazione dell'origine dati genera un errore, viene eseguito il modello di mappatura della risposta e il risultato valutato viene inserito all'interno del blocco di `errors.data` della risposta GraphQL.