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à.
# Creazione di interrogazioni di base () JavaScript
I resolver GraphQL connettono i campi nello schema di un tipo a un'origine dati. I resolver sono il meccanismo mediante il quale vengono soddisfatte le richieste.
Resolver AWS AppSync utilizzati JavaScript per convertire un'espressione GraphQL in un formato utilizzabile dall'origine dati. In alternativa, i modelli di mappatura possono essere scritti in [Apache Velocity Template Language (VTL) per](https://velocity.apache.org/engine/2.0/vtl-reference.html) convertire un'espressione GraphQL in un formato utilizzabile dall'origine dati.
Questa sezione descrive come configurare i resolver utilizzando. JavaScript La sezione [Resolver tutorials (JavaScript) fornisce tutorial](https://docs.aws.amazon.com/appsync/latest/devguide/tutorials-js.html) approfonditi su come implementare i resolver utilizzando. JavaScript La sezione [Resolver reference (JavaScript) fornisce una spiegazione delle operazioni di utilità che possono essere utilizzate con i resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-js-version.html). JavaScript
Consigliamo di seguire questa guida prima di tentare di utilizzare uno qualsiasi dei tutorial sopra citati.
In questa sezione, spiegheremo come creare e configurare resolver per query e mutazioni.
**Nota**
Questa guida presuppone che tu abbia creato il tuo schema e che tu abbia almeno una query o una mutazione. [Se stai cercando abbonamenti (dati in tempo reale), consulta questa guida.](https://docs.aws.amazon.com/appsync/latest/devguide/aws-appsync-real-time-data.html)
In questa sezione, forniremo alcuni passaggi generali per la configurazione dei resolver insieme a un esempio che utilizza lo schema seguente:
```
// schema.graphql file
input CreatePostInput {
title: String
date: AWSDateTime
}
type Post {
id: ID!
title: String
date: AWSDateTime
}
type Mutation {
createPost(input: CreatePostInput!): Post
}
type Query {
getPost: [Post]
}
```
## Creazione di risolutori di query di base
Questa sezione ti mostrerà come creare un risolutore di query di base.
------
#### [ Console ]
1. [Accedi a Console di gestione AWS e apri la AppSync console.](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. Inserisci i dettagli dello schema e della fonte di dati. Per ulteriori informazioni, consulta [le sezioni Progettazione dello schema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) e [Collegamento di un'origine dati](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html).
1. Accanto all'editor dello **schema**, c'è una finestra chiamata **Resolvers**. **Questa casella contiene un elenco dei tipi e dei campi definiti nella finestra Schema.** È possibile allegare resolver ai campi. Molto probabilmente allegherai dei resolver alle tue operazioni sul campo. In questa sezione, esamineremo semplici configurazioni di query. Nella sezione Tipo di **query**, scegli **Allega** accanto al campo della query.
1. Nella pagina **Attach resolver**, in **Tipo di resolver**, puoi scegliere tra resolver pipeline o unit. [Per ulteriori informazioni su questi tipi, consulta Resolvers.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Questa guida utilizzerà. `pipeline resolvers`
**Suggerimento**
Durante la creazione di risolutori di pipeline, le sorgenti dati verranno allegate alle funzioni della pipeline. Le funzioni vengono create dopo aver creato il risolutore della pipeline stesso, motivo per cui non è possibile impostarlo in questa pagina. Se utilizzi un risolutore di unità, la fonte di dati è collegata direttamente al resolver, quindi devi impostarla in questa pagina.
Per **Resolver runtime, scegli di abilitare il runtime**. `APPSYNC_JS` JavaScript
1. Puoi abilitare la [memorizzazione nella cache per questa API](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html). Ti consigliamo di disattivare questa funzionalità per ora. Scegli **Create** (Crea).
1. Nella pagina **Modifica resolver**, c'è un editor di codice chiamato **Resolver code** che consente di implementare la logica per il gestore e la risposta del resolver (prima e dopo i passaggi). [Per ulteriori informazioni, consulta la panoramica dei resolver. JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html)
**Nota**
[Nel nostro esempio, lasceremo la richiesta vuota e la risposta impostata per restituire l'ultima fonte di dati risultante dal contesto:](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html)
```
import {util} from '@aws-appsync/utils';
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Sotto questa sezione, c'è una tabella chiamata **Funzioni**. Le funzioni consentono di implementare codice che può essere riutilizzato su più resolver. Invece di riscrivere o copiare costantemente il codice, puoi memorizzare il codice sorgente come funzione da aggiungere a un resolver ogni volta che ne hai bisogno.
Le funzioni costituiscono la maggior parte dell'elenco delle operazioni di una pipeline. Quando si utilizzano più funzioni in un resolver, si imposta l'ordine delle funzioni e queste verranno eseguite in quell'ordine in sequenza. Vengono eseguiti dopo l'esecuzione della funzione di richiesta e prima dell'inizio della funzione di risposta.
Per aggiungere una nuova funzione, in **Funzioni**, scegli **Aggiungi funzione**, quindi **Crea nuova funzione**. In alternativa, potresti invece visualizzare il pulsante **Crea funzione** tra cui scegliere.
1. Scegli una fonte di dati. Questa sarà la fonte di dati su cui agisce il resolver.
**Nota**
Nel nostro esempio, stiamo collegando un resolver per`getPost`, che recupera un oggetto tramite. `Post` `id` Supponiamo di aver già impostato una tabella DynamoDB per questo schema. La sua chiave di partizione è impostata su `id` ed è vuota.
1. Inserisci un`Function name`.
1. In **Codice funzione**, dovrai implementare il comportamento della funzione. Ciò potrebbe creare confusione, ma ogni funzione avrà il proprio gestore locale di richieste e risposte. La richiesta viene eseguita, quindi viene effettuata la chiamata all'origine dati per gestire la richiesta, quindi la risposta dell'origine dati viene elaborata dal gestore della risposta. [Il risultato viene archiviato nell'oggetto contestuale.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html) Successivamente, verrà eseguita la funzione successiva nell'elenco o verrà passata al gestore di risposte post-passaggio se è l'ultima.
**Nota**
Nel nostro esempio, stiamo collegando un resolver a`getPost`, che ottiene un elenco di `Post` oggetti dalla fonte di dati. La nostra funzione di richiesta richiederà i dati dalla nostra tabella, la tabella passerà la sua risposta al contesto (ctx), quindi la risposta restituirà il risultato nel contesto. AWS AppSync la forza di questa soluzione risiede nella sua interconnessione con altri servizi. AWS Poiché utilizziamo DynamoDB, disponiamo di [una suite di](https://docs.aws.amazon.com/appsync/latest/devguide/js-resolver-reference-dynamodb.html) operazioni per semplificare cose come queste. Abbiamo anche alcuni esempi standard per altri tipi di fonti di dati.
Il nostro codice sarà simile a questo:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
In questo passaggio, abbiamo aggiunto due funzioni:
`request`: Il gestore della richiesta esegue l'operazione di recupero sulla fonte di dati. L'argomento contiene l'oggetto context (`ctx`) o alcuni dati disponibili per tutti i resolver che eseguono una particolare operazione. Ad esempio, potrebbe contenere dati di autorizzazione, i nomi dei campi da risolvere, ecc. L'istruzione return esegue un'[https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-scan)operazione (vedi [qui](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Scan.html) per alcuni esempi). Poiché lavoriamo con DynamoDB, siamo autorizzati a utilizzare alcune delle operazioni di quel servizio. La scansione esegue un recupero di base di tutti gli elementi della nostra tabella. Il risultato di questa operazione viene archiviato nell'oggetto di contesto come `result` contenitore prima di essere passato al gestore delle risposte. `request`Viene eseguito prima della risposta nella pipeline.
`response`: Il gestore di risposte che restituisce l'output di. `request` L'argomento è l'oggetto di contesto aggiornato e l'istruzione return è`ctx.prev.result`. A questo punto della guida, potresti non avere familiarità con questo valore. `ctx`si riferisce all'oggetto contestuale. `prev`si riferisce all'operazione precedente nella pipeline, che era la nostra`request`. `result`Contiene i risultati del resolver mentre si muove attraverso la pipeline. Se metti tutto insieme, `ctx.prev.result` restituisce il risultato dell'ultima operazione eseguita, che era il gestore della richiesta.
1. Scegli **Crea** dopo aver finito.
1. Tornando alla schermata del resolver, in **Funzioni**, scegli il menu a discesa **Aggiungi funzione** e aggiungi la tua funzione all'elenco delle funzioni.
1. Scegli **Salva** per aggiornare il resolver.
------
#### [ CLI ]
**Per aggiungere la tua funzione**
+ Crea una funzione per il tuo risolutore di pipeline usando il comando. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Dovrai inserire alcuni parametri per questo particolare comando:
1. La `api-id` della tua API.
1. `name`La funzione nella AWS AppSync console.
1. Il`data-source-name`, o il nome dell'origine dati che verrà utilizzata dalla funzione. Deve essere già stato creato e collegato all'API GraphQL nel AWS AppSync servizio.
1. L'`runtime`ambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essere`APPSYNC_JS`, e il runtime,`1.0.0`.
1. I `code` gestori di richieste e risposte della funzione. Sebbene sia possibile digitarlo manualmente, è molto più semplice aggiungerlo a un file.txt (o un formato simile) e quindi passarlo come argomento.
**Nota**
Il nostro codice di query sarà contenuto in un file passato come argomento:
```
import { util } from '@aws-appsync/utils';
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
return { operation: 'Scan' };
}
/**
* return a list of scanned post items
*/
export function response(ctx) {
return ctx.result.items;
}
```
Un comando di esempio può essere simile al seguente:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name get_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file://~/path/to/file/{filename}.{fileType}
```
Verrà restituito un output nella CLI. Ecco un esempio:
```
{
"functionConfiguration": {
"functionId": "ejglgvmcabdn7lx75ref4qeig4",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/ejglgvmcabdn7lx75ref4qeig4",
"name": "get_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
**Nota**
Assicurati di registrarlo `functionId` da qualche parte poiché verrà utilizzato per collegare la funzione al resolver.
**Per creare il tuo resolver**
+ Crea una funzione di pipeline `Query` eseguendo il comando. `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`
Dovrai inserire alcuni parametri per questo particolare comando:
1. La `api-id` della tua API.
1. Il`type-name`, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription).
1. Il`field-name`, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver.
1. Il`kind`, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni della `PIPELINE` pipeline.
1. La`pipeline-config`, o la o le funzioni da collegare al resolver. Assicurati di conoscere `functionId` i valori delle tue funzioni. L'ordine delle inserzioni è importante.
1. Il`runtime`, che era `APPSYNC_JS` (JavaScript). `runtimeVersion`Attualmente è`1.0.0`.
1. Il`code`, che contiene i gestori della fase prima e dopo.
**Nota**
Il nostro codice di query sarà in un file passato come argomento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando di esempio può essere simile al seguente:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Query \
--field-name getPost \
--kind PIPELINE \
--pipeline-config functions=ejglgvmcabdn7lx75ref4qeig4 \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Verrà restituito un output nella CLI. Ecco un esempio:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "getPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/getPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"ejglgvmcabdn7lx75ref4qeig4"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Suggerimento**
[Prima di utilizzare il CDK, consigliamo di consultare la [documentazione ufficiale del CDK insieme AWS AppSync al riferimento](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
I passaggi elencati di seguito mostreranno solo un esempio generale dello snippet utilizzato per aggiungere una particolare risorsa. Questa **non** è pensata per essere una soluzione funzionante nel codice di produzione. Supponiamo inoltre che tu abbia già un'app funzionante.
Un'app di base avrà bisogno delle seguenti cose:
1. Direttive di importazione dei servizi
1. Codice dello schema
1. Generatore di fonti di dati
1. Codice di funzione
1. Codice del resolver
Dalle sezioni [Progettazione dello schema](https://docs.aws.amazon.com/appsync/latest/devguide/designing-your-schema.html) e [Allegare una fonte di dati](https://docs.aws.amazon.com/appsync/latest/devguide/attaching-a-data-source.html), sappiamo che il file stack includerà le direttive di importazione del modulo:
```
import * as x from 'x'; # import wildcard as the 'x' keyword from 'x-service'
import {a, b, ...} from 'c'; # import {specific constructs} from 'c-service'
```
**Nota**
Nelle sezioni precedenti, abbiamo solo indicato come importare i costrutti. AWS AppSync In codice reale, dovrai importare più servizi solo per eseguire l'app. Nel nostro esempio, se dovessimo creare un'app CDK molto semplice, importeremmo almeno il AWS AppSync servizio insieme alla nostra fonte di dati, che era una tabella DynamoDB. Dovremmo anche importare alcuni costrutti aggiuntivi per distribuire l'app:
```
import * as cdk from 'aws-cdk-lib';
import * as appsync from 'aws-cdk-lib/aws-appsync';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
import { Construct } from 'constructs';
```
Per riassumere ognuno di questi:
`import * as cdk from 'aws-cdk-lib';`: Ciò consente di definire l'app CDK e i costrutti come lo stack. Contiene anche alcune utili funzioni di utilità per la nostra applicazione, come la manipolazione dei metadati. [Se conosci questa direttiva di importazione, ma ti stai chiedendo perché la libreria di base cdk non viene utilizzata qui, consulta la pagina Migrazione.](https://docs.aws.amazon.com/cdk/v2/guide/migrating-v2.html)
`import * as appsync from 'aws-cdk-lib/aws-appsync';`: Questo importa il [AWS AppSync servizio](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html).
`import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';`: Importa il servizio [DynamoDB](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_dynamodb-readme.html).
`import { Construct } from 'constructs';`[: Ne abbiamo bisogno per definire il costrutto root.](https://docs.aws.amazon.com/cdk/v2/guide/constructs.html)
Il tipo di importazione dipende dai servizi che stai chiamando. Ti consigliamo di consultare la documentazione CDK per alcuni esempi. Lo schema nella parte superiore della pagina sarà un file separato nell'app CDK come `.graphql` file. Nel file stack, possiamo associarlo a un nuovo GraphQL utilizzando il modulo:
```
const add_api = new appsync.GraphqlApi(this, 'graphQL-example', {
name: 'my-first-api',
schema: appsync.SchemaFile.fromAsset(path.join(__dirname, 'schema.graphql')),
});
```
**Nota**
Nell'ambito`add_api`, stiamo aggiungendo una nuova API GraphQL utilizzando la `new` parola chiave seguita da. `appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)` Il nostro ambito è`this`, l'id CFN è `graphQL-example` e i nostri oggetti di scena sono `my-first-api` (nome dell'API nella console) e `schema.graphql` (il percorso assoluto del file di schema).
Per aggiungere una fonte di dati, devi prima aggiungere la tua fonte di dati allo stack. Quindi, è necessario associarlo all'API GraphQL utilizzando il metodo specifico del codice sorgente. L'associazione avverrà quando farai funzionare il resolver. Nel frattempo, facciamo un esempio creando la tabella DynamoDB usando: `dynamodb.Table`
```
const add_ddb_table = new dynamodb.Table(this, 'posts-table', {
partitionKey: {
name: 'id',
type: dynamodb.AttributeType.STRING,
},
});
```
**Nota**
Se dovessimo utilizzarlo nel nostro esempio, aggiungeremmo una nuova tabella DynamoDB con l'id CFN `posts-table` di e una chiave di partizione di. `id (S)`
Successivamente, dobbiamo implementare il nostro resolver nel file stack. Ecco un esempio di una semplice query che analizza tutti gli elementi in una tabella DynamoDB:
```
const add_func = new appsync.AppsyncFunction(this, 'func-get-posts', {
name: 'get_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return { operation: 'Scan' };
}
export function response(ctx) {
return ctx.result.items;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-get-posts', {
add_api,
typeName: 'Query',
fieldName: 'getPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func],
});
```
**Nota**
Innanzitutto, abbiamo creato una funzione chiamata. `add_func` Questo ordine di creazione può sembrare un po' controintuitivo, ma è necessario creare le funzioni nel resolver della pipeline prima di creare il resolver stesso. Una funzione segue la forma:
```
AppsyncFunction(scope: Construct, id: string, props: AppsyncFunctionProps)
```
Il nostro ambito era`this`, il nostro ID CFN lo era `func-get-posts` e i nostri oggetti di scena contenevano i dettagli effettivi della funzione. All'interno degli oggetti di scena, abbiamo incluso:
La `name` funzione che sarà presente nella AWS AppSync console (`get_posts_func_1`).
L'API GraphQL che abbiamo creato in precedenza ()`add_api`.
L'origine dei dati; questo è il punto in cui colleghiamo l'origine dati al valore dell'API GraphQL, quindi la colleghiamo alla funzione. Prendiamo la tabella che abbiamo creato (`add_ddb_table`) e la colleghiamo all'API GraphQL (`add_api`) utilizzando uno dei `GraphqlApi` metodi ([https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.GraphqlApi.html#addwbrdynamowbrdbwbrdatawbrsourceid-table-options)). Il valore id (`table-for-posts`) è il nome dell'origine dati nella AWS AppSync console. Per un elenco di metodi specifici dell'origine, consulta le pagine seguenti:
[ DynamoDbDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.DynamoDbDataSource.html)
[ EventBridgeDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.EventBridgeDataSource.html)
[ HttpDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.HttpDataSource.html)
[ LambdaDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.LambdaDataSource.html)
[ NoneDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.NoneDataSource.html)
[ OpenSearchDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.OpenSearchDataSource.html)
[ RdsDataSource ](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync.RdsDataSource.html)
Il codice contiene i gestori di richiesta e risposta della nostra funzione, che consistono in una semplice scansione e restituzione.
Il runtime specifica che vogliamo usare la versione di runtime APPSYNC\$1JS 1.0.0. Nota che questa è attualmente l'unica versione disponibile per APPSYNC\$1JS.
Successivamente, dobbiamo collegare la funzione al risolutore della pipeline. Abbiamo creato il nostro resolver utilizzando il modulo:
```
Resolver(scope: Construct, id: string, props: ResolverProps)
```
Il nostro ambito era`this`, il nostro ID CFN lo era `pipeline-resolver-get-posts` e i nostri oggetti di scena contenevano i dettagli effettivi della funzione. All'interno degli oggetti di scena, abbiamo incluso:
L'API GraphQL che abbiamo creato in precedenza ()`add_api`.
Il nome speciale del tipo di oggetto; si tratta di un'operazione di interrogazione, quindi abbiamo semplicemente aggiunto il valore`Query`.
Il nome del campo (`getPost`) è il nome del campo nello schema sotto il `Query` tipo.
Il codice contiene i gestori prima e dopo. Il nostro esempio restituisce semplicemente i risultati presenti nel contesto dopo che la funzione ha eseguito la sua operazione.
Il runtime specifica che vogliamo usare la versione di runtime APPSYNC\$1JS 1.0.0. Nota che questa è attualmente l'unica versione disponibile per APPSYNC\$1JS.
La configurazione della pipeline contiene il riferimento alla funzione che abbiamo creato (). `add_func`
------
Per riassumere ciò che è successo in questo esempio, hai visto una AWS AppSync funzione che implementava un gestore di richieste e risposte. La funzione era responsabile dell'interazione con la fonte dei dati. Il gestore della richiesta ha inviato un'`Scan`operazione a AWS AppSync, indicandogli quale operazione eseguire sull'origine dati DynamoDB. Il gestore della risposta ha restituito l'elenco degli elementi (). `ctx.result.items` L'elenco degli elementi è stato quindi mappato automaticamente al tipo `Post` GraphQL.
## Creazione di risolutori di mutazioni di base
Questa sezione ti mostrerà come creare un risolutore di mutazioni di base.
------
#### [ Console ]
1. [Accedi a Console di gestione AWS e apri la console. AppSync](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Schema.**
1. Nella sezione **Resolver** e nel tipo di **mutazione**, scegli **Allega** accanto al tuo campo.
**Nota**
Nel nostro esempio, stiamo collegando un resolver per`createPost`, che aggiunge un oggetto alla nostra tabella. `Post` Supponiamo di utilizzare la stessa tabella DynamoDB dell'ultima sezione. La sua chiave di partizione è impostata su `id` ed è vuota.
1. Nella pagina **Allega resolver**, in Tipo di **risolutore, scegli**. `pipeline resolvers` [Come promemoria, puoi trovare ulteriori informazioni sui resolver qui.](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-components.html) Per **Resolver runtime, scegli di abilitare il runtime**. `APPSYNC_JS` JavaScript
1. Puoi abilitare la [memorizzazione nella cache per questa API](https://docs.aws.amazon.com/appsync/latest/devguide/enabling-caching.html). Ti consigliamo di disattivare questa funzionalità per ora. Scegli **Create** (Crea).
1. Scegli **Aggiungi funzione**, quindi scegli **Crea nuova funzione**. In alternativa, potresti invece visualizzare un pulsante **Crea funzione** tra cui scegliere.
1. Scegli l'origine dati. Questa dovrebbe essere la fonte di cui manipolerai i dati con la mutazione.
1. Inserisci un. `Function name`
1. In **Codice funzione**, dovrai implementare il comportamento della funzione. Questa è una mutazione, quindi la richiesta eseguirà idealmente alcune operazioni di modifica dello stato sulla fonte di dati richiamata. Il risultato verrà elaborato dalla funzione di risposta.
**Nota**
`createPost`sta aggiungendo, o «inserendo», un nuovo `Post` nella tabella con i nostri parametri come dati. Potremmo aggiungere qualcosa del genere:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
In questo passaggio, abbiamo anche aggiunto `request` `response` funzioni:
`request`: Il gestore della richiesta accetta il contesto come argomento. L'istruzione return del gestore di richieste esegue un [https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem](https://docs.aws.amazon.com//appsync/latest/devguide/js-resolver-reference-dynamodb.html#js-aws-appsync-resolver-reference-dynamodb-putitem)comando, che è un'operazione DynamoDB integrata ([vedi](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/getting-started-step-2.html) qui [o](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/WorkingWithItems.html#WorkingWithItems.WritingData) qui per alcuni esempi). Il `PutItem` comando aggiunge un `Post` oggetto alla nostra tabella DynamoDB prendendo il valore della `key` partizione (generato automaticamente `util.autoid()` da) `attributes` e dall'input dell'argomento di contesto (questi sono i valori che passeremo nella nostra richiesta). Gli argomenti `key` è `id` e `attributes` sono gli `date` e `title` i campi. Sono entrambi preformattati tramite l'[https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js](https://docs.aws.amazon.com//appsync/latest/devguide/dynamodb-helpers-in-util-dynamodb-js.html#utility-helpers-in-toMap-js)helper per funzionare con la tabella DynamoDB.
`response`: La risposta accetta il contesto aggiornato e restituisce il risultato del gestore della richiesta.
1. Scegli **Crea** dopo aver finito.
1. Tornando alla schermata del resolver, in **Funzioni**, scegli il menu a discesa **Aggiungi funzione** e aggiungi la tua funzione all'elenco delle funzioni.
1. Scegli **Salva** per aggiornare il resolver.
------
#### [ CLI ]
**Per aggiungere la tua funzione**
+ Crea una funzione per il tuo risolutore di pipeline usando il comando. `[create-function](https://docs.aws.amazon.com/cli/latest/reference/appsync/create-function.html)`
Dovrai inserire alcuni parametri per questo particolare comando:
1. La `api-id` della tua API.
1. `name`La funzione nella AWS AppSync console.
1. Il`data-source-name`, o il nome dell'origine dati che verrà utilizzata dalla funzione. Deve essere già stato creato e collegato all'API GraphQL nel AWS AppSync servizio.
1. L'`runtime`ambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essere`APPSYNC_JS`, e il runtime,`1.0.0`.
1. I `code` gestori di richieste e risposte della funzione. Sebbene sia possibile digitarlo manualmente, è molto più semplice aggiungerlo a un file.txt (o un formato simile) e passarlo come argomento.
**Nota**
Il nostro codice di query sarà contenuto in un file passato come argomento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando di esempio può essere simile al seguente:
```
aws appsync create-function \
--api-id abcdefghijklmnopqrstuvwxyz \
--name add_posts_func_1 \
--data-source-name table-for-posts \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Verrà restituito un output nella CLI. Ecco un esempio:
```
{
"functionConfiguration": {
"functionId": "vulcmbfcxffiram63psb4dduoa",
"functionArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/functions/vulcmbfcxffiram63psb4dduoa",
"name": "add_posts_func_1",
"dataSourceName": "table-for-posts",
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output foes here"
}
}
```
**Nota**
Assicurati di registrarlo `functionId` da qualche parte poiché verrà utilizzato per collegare la funzione al resolver.
**Per creare il tuo resolver**
+ Crea una funzione di pipeline `Mutation` eseguendo il comando. `[create-resolver](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/appsync/create-resolver.html)`
Dovrai inserire alcuni parametri per questo particolare comando:
1. La `api-id` della tua API.
1. Il`type-name`, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription).
1. Il`field-name`, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver.
1. Il`kind`, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni della `PIPELINE` pipeline.
1. La`pipeline-config`, o la o le funzioni da collegare al resolver. Assicurati di conoscere `functionId` i valori delle tue funzioni. L'ordine delle inserzioni è importante.
1. Il`runtime`, che era `APPSYNC_JS` (JavaScript). `runtimeVersion`Attualmente è`1.0.0`.
1. Il`code`, che contiene il passaggio prima e dopo.
**Nota**
Il nostro codice di query sarà in un file passato come argomento:
```
import { util } from '@aws-appsync/utils';
/**
* Sends a request to `put` an item in the DynamoDB data source
*/
export function request(ctx) {
const { id, ...values } = ctx.args;
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id }),
attributeValues: util.dynamodb.toMapValues(values),
};
}
/**
* returns the result of the `put` operation
*/
export function response(ctx) {
return ctx.result;
}
```
Un comando di esempio può essere simile al seguente:
```
aws appsync create-resolver \
--api-id abcdefghijklmnopqrstuvwxyz \
--type-name Mutation \
--field-name createPost \
--kind PIPELINE \
--pipeline-config functions=vulcmbfcxffiram63psb4dduoa \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0 \
--code file:///path/to/file/{filename}.{fileType}
```
Verrà restituito un output nella CLI. Ecco un esempio:
```
{
"resolver": {
"typeName": "Mutation",
"fieldName": "createPost",
"resolverArn": "arn:aws:appsync:us-west-2:107289374856:apis/abcdefghijklmnopqrstuvwxyz/types/Mutation/resolvers/createPost",
"kind": "PIPELINE",
"pipelineConfig": {
"functions": [
"vulcmbfcxffiram63psb4dduoa"
]
},
"maxBatchSize": 0,
"runtime": {
"name": "APPSYNC_JS",
"runtimeVersion": "1.0.0"
},
"code": "Code output goes here"
}
}
```
------
#### [ CDK ]
**Suggerimento**
[Prima di utilizzare il CDK, consigliamo di consultare la [documentazione ufficiale del CDK insieme AWS AppSync al riferimento](https://docs.aws.amazon.com/cdk/v2/guide/home.html) CDK.](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_appsync-readme.html)
I passaggi elencati di seguito mostreranno solo un esempio generale dello snippet utilizzato per aggiungere una particolare risorsa. Questa **non** è pensata per essere una soluzione funzionante nel codice di produzione. Supponiamo inoltre che tu abbia già un'app funzionante.
+ Per effettuare una mutazione, supponendo che siate nello stesso progetto, potete aggiungerla allo stack file come nella query. Ecco una funzione e un resolver modificati per una mutazione che ne aggiunge una nuova alla tabella: `Post`
```
const add_func_2 = new appsync.AppsyncFunction(this, 'func-add-post', {
name: 'add_posts_func_1',
add_api,
dataSource: add_api.addDynamoDbDataSource('table-for-posts-2', add_ddb_table),
code: appsync.Code.fromInline(`
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({id: util.autoId()}),
attributeValues: util.dynamodb.toMapValues(ctx.args.input),
};
}
export function response(ctx) {
return ctx.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
});
new appsync.Resolver(this, 'pipeline-resolver-create-posts', {
add_api,
typeName: 'Mutation',
fieldName: 'createPost',
code: appsync.Code.fromInline(`
export function request(ctx) {
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
`),
runtime: appsync.FunctionRuntime.JS_1_0_0,
pipelineConfig: [add_func_2],
});
```
**Nota**
Poiché questa mutazione e la query sono strutturate in modo simile, ci limiteremo a spiegare le modifiche che abbiamo apportato per apportare la mutazione.
Nella funzione, abbiamo cambiato l'id CFN in `func-add-post` e il nome in `add_posts_func_1` per riflettere il fatto che stiamo aggiungendo `Posts` alla tabella. Nell'origine dati, abbiamo creato una nuova associazione alla nostra table (`add_ddb_table`) nella AWS AppSync console `table-for-posts-2` perché il `addDynamoDbDataSource` metodo lo richiede. Tieni presente che questa nuova associazione utilizza ancora la stessa tabella che abbiamo creato in precedenza, ma ora abbiamo due connessioni ad essa nella AWS AppSync console: una per la query as `table-for-posts` e una per la mutazione as`table-for-posts-2`. Il codice è stato modificato per aggiungere un valore `Post` generando automaticamente il suo `id` valore e accettando l'input di un client per il resto dei campi.
Nel resolver, abbiamo modificato il valore id in modo `pipeline-resolver-create-posts` che rifletta il fatto che stiamo aggiungendo `Posts` alla tabella. Per riflettere la mutazione nello schema, il nome del tipo è stato cambiato in`Mutation`, e il nome,. `createPost` La configurazione della pipeline è stata impostata sulla nostra nuova funzione di mutazione. `add_func_2`
------
Per riassumere ciò che sta accadendo in questo esempio, converte AWS AppSync automaticamente gli argomenti definiti nel `createPost` campo dallo schema GraphQL in operazioni DynamoDB. L'esempio archivia i record in DynamoDB utilizzando una chiave `id` di, che viene creata automaticamente utilizzando il nostro helper. `util.autoId()` Tutti gli altri campi passati agli argomenti di contesto (`ctx.args.input`) dalle richieste effettuate nella AWS AppSync console o in altro modo verranno memorizzati come attributi della tabella. Sia la chiave che gli attributi vengono mappati automaticamente su un formato DynamoDB compatibile utilizzando l'helper. `util.dynamodb.toMapValues(values)`
AWS AppSync supporta anche flussi di lavoro di test e debug per la modifica dei resolver. È possibile utilizzare un `context` oggetto fittizio per vedere il valore trasformato del modello prima di richiamarlo. Facoltativamente, puoi visualizzare la richiesta completa a un'origine dati in modo interattivo quando esegui una query. [Per ulteriori informazioni, vedete [Test and debug resolvers () JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/test-debug-resolvers-js.html) e Monitoring and logging.](https://docs.aws.amazon.com/appsync/latest/devguide/monitoring.html#aws-appsync-monitoring)
## Resolver avanzati
Se stai seguendo la sezione opzionale sull'impaginazione in [Progettazione dello schema](designing-your-schema.md#aws-appsync-designing-your-schema), devi comunque aggiungere il resolver alla richiesta per utilizzare l'impaginazione. Il nostro esempio ha utilizzato una paginazione di query chiamata `getPosts` per restituire solo una parte degli elementi richiesti alla volta. Il codice del nostro resolver su quel campo potrebbe essere simile al seguente:
```
/**
* Performs a scan on the dynamodb data source
*/
export function request(ctx) {
const { limit = 20, nextToken } = ctx.args;
return { operation: 'Scan', limit, nextToken };
}
/**
* @returns the result of the `put` operation
*/
export function response(ctx) {
const { items: posts = [], nextToken } = ctx.result;
return { posts, nextToken };
}
```
Nella richiesta, passiamo nel contesto della richiesta. Il nostro `limit` è*20*, il che significa che restituiamo fino a 20 `Posts` nella prima query. Il nostro `nextToken` cursore è fissato alla prima `Post` voce nella fonte di dati. Questi vengono passati agli args. La richiesta esegue quindi una scansione dalla prima `Post` fino al numero limite di scansione. L'origine dati memorizza il risultato nel contesto, che viene passato alla risposta. La risposta `Posts` restituisce la risposta recuperata, quindi imposta l'impostazione `nextToken` è impostata sulla `Post` voce subito dopo il limite. La richiesta successiva viene inviata per fare esattamente la stessa cosa, ma a partire dall'offset subito dopo la prima query. Tieni presente che questo tipo di richieste vengono eseguite in sequenza e non in parallelo.
# Test e debug dei resolver in () AWS AppSync JavaScript
AWS AppSync esegue resolver su un campo GraphQL su un'origine dati. Quando si lavora con i resolver per pipeline, le funzioni interagiscono con le fonti di dati. Come descritto nella [panoramica dei JavaScript resolver, le funzioni comunicano con le fonti di dati utilizzando gestori](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html) di richieste e risposte scritti ed eseguiti nel runtime. JavaScript `APPSYNC_JS` Ciò consente di fornire logica e condizioni personalizzate prima e dopo la comunicazione con l'origine dati.
Per aiutare gli sviluppatori a scrivere, testare ed eseguire il debug di questi resolver, la AWS AppSync console fornisce anche strumenti per creare una richiesta e una risposta GraphQL con dati fittizi fino al singolo resolver di campo. Inoltre, puoi eseguire query, mutazioni e sottoscrizioni nella AWS AppSync console e visualizzare un flusso di log dettagliato dell'intera richiesta proveniente da Amazon. CloudWatch Ciò include i risultati della fonte di dati.
## Test con dati fittizi
Quando viene richiamato un resolver GraphQL, contiene un `context` oggetto che contiene informazioni pertinenti sulla richiesta. Tali informazioni includono gli argomenti provenienti da un client, le informazioni sull'identità e i dati del campo GraphQL padre. Memorizza anche i risultati della fonte di dati, che può essere utilizzata nel gestore delle risposte. Per ulteriori informazioni su questa struttura e sulle utilità di supporto disponibili da utilizzare durante la programmazione, vedete il riferimento all'oggetto contestuale [Resolver](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-context-reference-js.html).
Quando si scrive o si modifica una funzione resolver, è possibile passare un oggetto contestuale *fittizio* o di *test* all'editor della console. Ciò consente di vedere come valutano sia il gestore di richiesta che quello di risposta senza che vengano effettivamente eseguiti su una fonte di dati. Puoi ad esempio passare un argomento `firstname: Shaggy` di test e vedere i relativi risultati quando usi `ctx.args.firstname` nel codice del modello. Puoi anche testare la valutazione di utilità helper, ad esempio `util.autoId()` o `util.time.nowISO8601()`.
### Test dei resolver
Questo esempio utilizzerà la AWS AppSync console per testare i resolver.
1. [Accedi a Console di gestione AWS e apri la console. AppSync](https://console.aws.amazon.com/appsync/)
1. Nella **APIs dashboard**, scegli la tua API GraphQL.
1. **Nella **barra laterale**, scegli Funzioni.**
1. Scegli una funzione esistente.
1. Nella parte superiore della pagina **Aggiorna funzione**, scegli **Seleziona contesto di test**, quindi scegli **Crea nuovo contesto**.
1. Seleziona un oggetto di contesto di esempio o compila il codice JSON manualmente nella finestra **Configura contesto di test** di seguito.
1. Immettete un nome per **il contesto di testo**.
1. Seleziona il pulsante **Save** (Salva).
1. Per valutare il resolver utilizzando l'oggetto context fittizio, scegliere **Run Test (Esegui test)**.
Per un esempio più pratico, supponiamo di avere un'app che memorizza un tipo GraphQL che utilizza la generazione automatica `Dog` di ID per gli oggetti e li archivia in Amazon DynamoDB. Vuoi anche scrivere alcuni valori dagli argomenti di una mutazione GraphQL e consentire solo a utenti specifici di vedere una risposta. Il seguente frammento mostra come potrebbe apparire lo schema:
```
type Dog {
breed: String
color: String
}
type Mutation {
addDog(firstname: String, age: Int): Dog
}
```
Puoi scrivere una AWS AppSync funzione e aggiungerla al tuo `addDog` resolver per gestire la mutazione. Per testare la tua AWS AppSync funzione, puoi compilare un oggetto di contesto come nell'esempio seguente. Il seguente include gli argomenti `name` e `age` del client, oltre che un elemento `username` popolato nell'oggetto `identity`:
```
{
"arguments" : {
"firstname": "Shaggy",
"age": 4
},
"source" : {},
"result" : {
"breed" : "Miniature Schnauzer",
"color" : "black_grey"
},
"identity": {
"sub" : "uuid",
"issuer" : " https://cognito-idp.{region}.amazonaws.com/{userPoolId}",
"username" : "Nadia",
"claims" : { },
"sourceIp" :[ "x.x.x.x" ],
"defaultAuthStrategy" : "ALLOW"
}
}
```
È possibile testare la AWS AppSync funzione utilizzando il codice seguente:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return {
operation: 'PutItem',
key: util.dynamodb.toMapValues({ id: util.autoId() }),
attributeValues: util.dynamodb.toMapValues(ctx.args),
};
}
export function response(ctx) {
if (ctx.identity.username === 'Nadia') {
console.log("This request is allowed")
return ctx.result;
}
util.unauthorized();
}
```
Il gestore di richieste e risposte valutato contiene i dati dell'oggetto del contesto di test e il valore generato da. `util.autoId()` Inoltre, se decidi di modificare `username` in un valore diverso da `Nadia`, i risultati non verranno restituiti perché il controllo di autorizzazione avrebbe esito negativo. [Per ulteriori informazioni sul controllo granulare degli accessi, consulta Casi d'uso delle autorizzazioni.](security-authorization-use-cases.md#aws-appsync-security-authorization-use-cases)
### Testare i gestori di richieste e risposte con's AWS AppSync APIs
Puoi utilizzare il comando `EvaluateCode` API per testare in remoto il tuo codice con dati simulati. Per iniziare con il comando, assicurati di aver aggiunto l'`appsync:evaluateMappingCode`autorizzazione alla tua politica. Esempio:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "appsync:evaluateCode",
"Resource": "arn:aws:appsync:us-east-1:111122223333:*"
}
]
}
```
------
È possibile sfruttare il comando utilizzando [AWS CLI](https://aws.amazon.com/cli/)o [AWS SDKs](https://aws.amazon.com/tools/). Ad esempio, prendiamo lo `Dog` schema e i relativi gestori di richiesta e risposta delle AWS AppSync funzioni della sezione precedente. Utilizzando la CLI sulla stazione locale, salvate il codice in un file denominato`code.js`, quindi salvate l'`context`oggetto in un file denominato. `context.json` Dalla tua shell, esegui il seguente comando:
```
$ aws appsync evaluate-code \
--code file://code.js \
--function response \
--context file://context.json \
--runtime name=APPSYNC_JS,runtimeVersion=1.0.0
```
La risposta contiene un file `evaluationResult` contenente il payload restituito dal gestore. Contiene anche un `logs` oggetto che contiene l'elenco dei log generati dal gestore durante la valutazione. Ciò semplifica il debug dell'esecuzione del codice e la visualizzazione delle informazioni sulla valutazione per facilitare la risoluzione dei problemi. Esempio:
```
{
"evaluationResult": "{\"breed\":\"Miniature Schnauzer\",\"color\":\"black_grey\"}",
"logs": [
"INFO - code.js:13:5: \"This request is allowed\""
]
}
```
`evaluationResult`Può essere analizzato come JSON, il che fornisce:
```
{
"breed": "Miniature Schnauzer",
"color": "black_grey"
}
```
Utilizzando l'SDK, puoi incorporare facilmente i test della tua suite di test preferita per convalidare il comportamento dei tuoi gestori. Ti consigliamo di creare test utilizzando [Jest Testing Framework, ma qualsiasi suite di test](https://jestjs.io/) funziona. Il seguente frammento mostra un'ipotetica esecuzione di convalida. Nota che ci aspettiamo che la risposta di valutazione sia un codice JSON valido, quindi lo utilizziamo `JSON.parse` per recuperare JSON dalla stringa di risposta:
```
const AWS = require('aws-sdk')
const fs = require('fs')
const client = new AWS.AppSync({ region: 'us-east-2' })
const runtime = {name:'APPSYNC_JS',runtimeVersion:'1.0.0')
test('request correctly calls DynamoDB', async () => {
const code = fs.readFileSync('./code.js', 'utf8')
const context = fs.readFileSync('./context.json', 'utf8')
const contextJSON = JSON.parse(context)
const response = await client.evaluateCode({ code, context, runtime, function: 'request' }).promise()
const result = JSON.parse(response.evaluationResult)
expect(result.key.id.S).toBeDefined()
expect(result.attributeValues.firstname.S).toEqual(contextJSON.arguments.firstname)
})
```
Ciò produce il seguente risultato:
```
Ran all test suites.
> jest
PASS ./index.test.js
✓ request correctly calls DynamoDB (543 ms)
Test Suites: 1 passed, 1 total
Tests: 1 passed, 1 total
Snapshots: 0 totalTime: 1.511 s, estimated 2 s
```
## Eseguire il debug di una query live
Non c'è nulla che possa sostituire un end-to-end test e una registrazione per eseguire il debug di un'applicazione di produzione. AWS AppSync consente di registrare gli errori e i dettagli completi delle richieste utilizzando Amazon CloudWatch. Inoltre, puoi utilizzare la AWS AppSync console per testare le query, le mutazioni e gli abbonamenti GraphQL e trasmettere in live streaming i dati di registro per ogni richiesta nell'editor di query per il debug in tempo reale. Per le sottoscrizioni, i log visualizzano le informazioni relative al tempo della connessione.
A tale scopo, è necessario che Amazon CloudWatch logs sia abilitato in anticipo, come descritto in [Monitoraggio e registrazione](monitoring.md#aws-appsync-monitoring). Successivamente, nella AWS AppSync console, scegli la scheda **Queries** e inserisci una query GraphQL valida. Nella sezione in basso a destra, fai clic e trascina la finestra **Logs per aprire** la visualizzazione dei log. Sulla parte superiore della pagina, scegliere l'icona con la freccia per la riproduzione per eseguire la query GraphQL. In pochi istanti, i registri completi delle richieste e delle risposte relativi all'operazione vengono trasmessi in streaming a questa sezione e possono essere visualizzati nella console.
# Configurazione e utilizzo dei resolver di pipeline in () AWS AppSync JavaScript
AWS AppSync esegue i resolver su un campo GraphQL. In alcuni casi, le applicazioni prevedono il compimento di più operazioni per la risoluzione di un singolo campo GraphQL. Con i resolver a pipeline, gli sviluppatori possono ora comporre operazioni chiamate Funzioni ed eseguirle in sequenza. Questo tipo di resolver torna utile, ad esempio, con applicazioni che prevedono un controllo delle autorizzazioni antecedente al recupero dei dati per un campo.
[Per ulteriori informazioni sull'architettura di un resolver di JavaScript pipeline, consulta la panoramica dei resolver. JavaScript](https://docs.aws.amazon.com/appsync/latest/devguide/resolver-reference-overview-js.html#anatomy-of-a-pipeline-resolver-js)
## Fase 1: Creazione di un risolutore di pipeline
**Nella AWS AppSync console, vai alla pagina Schema.**
Salva lo schema seguente:
```
schema {
query: Query
mutation: Mutation
}
type Mutation {
signUp(input: Signup): User
}
type Query {
getUser(id: ID!): User
}
input Signup {
username: String!
email: String!
}
type User {
id: ID!
username: String
email: AWSEmail
}
```
Bisogna implementare un resolver di pipeline per il campo **signUp (registrazione)** del tipo di **Mutation (Mutazione)**. Nel tipo di **mutazione** sul lato destro, scegli **Allega** accanto al campo di `signUp` mutazione. Imposta il resolver su `pipeline resolver` e il `APPSYNC_JS` runtime, quindi crea il resolver.
Il nostra resolver di pipeline registra un utente convalidandone l'indirizzo e-mail e, successivamente, salvandolo nel sistema. **Incapsuleremo la convalida dell'e-mail all'interno di una funzione ValidateEmail e il salvataggio dell'**utente all'interno** di una funzione SaveUser.** Per prima, viene eseguita la funzione **validateEmail**, al termine della quale e solo se appurata la validità dell'e-mail, si può procedere con la **saveUser**.
Il flusso di esecuzione sarà il seguente:
1. Gestore di richieste del resolver Mutation.signup
1. Funzione validateEmail
1. Funzione saveUser
1. Gestore di risposte del resolver Mutation.signup
Poiché probabilmente riutilizzeremo la funzione **ValidateEmail** in altri resolver sulla nostra API, vogliamo evitare l'accesso `ctx.args` perché questi cambieranno da un campo GraphQL all'altro. In alternativa, è possibile avvalersi di `ctx.stash` per memorizzare l'attributo e-mail dall'argomento del campo di input `signUp(input: Signup)`.
Aggiorna il codice del resolver sostituendo le funzioni di richiesta e risposta:
```
export function request(ctx) {
ctx.stash.email = ctx.args.input.email
return {};
}
export function response(ctx) {
return ctx.prev.result;
}
```
Scegli **Crea** o **Salva** per aggiornare il resolver.
## Fase 2: Creazione di una funzione
Dalla pagina Pipeline Resolver, nella sezione **Funzioni**, fai clic su **Aggiungi funzione, quindi su **Crea** nuova funzione**. **È anche possibile creare funzioni senza passare dalla pagina del resolver; per farlo, nella AWS AppSync console, vai alla pagina Funzioni.** Selezionare il pulsante **Create function (Crea funzione)**. Creiamo quindi una funzione che verifichi la validità e la provenienza da un determinato dominio di un indirizzo e-mail. In caso di e-mail non valida, la funzione restituisce un errore. Altrimenti, inoltra qualsiasi input immesso.
Assicurati di aver creato una fonte di dati del tipo **NONE**. Scegli questa fonte di **dati nell'elenco Nome origine dati**. Per il **nome della funzione**, immettete`validateEmail`. Nell'area del **codice della funzione**, sovrascrivi tutto con questo frammento:
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
const { email } = ctx.stash;
const valid = util.matches(
'^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com',
email
);
if (!valid) {
util.error(`"${email}" is not a valid email.`);
}
return { payload: { email } };
}
export function response(ctx) {
return ctx.result;
}
```
**Controlla i dati inseriti, quindi scegli Crea.** A questo punto, la funzione **validateEmail** è stata creata. **Ripeti questi passaggi per creare la funzione SaveUser con il codice seguente (per semplicità, utilizziamo **una** fonte di dati NONE e facciamo finta che l'utente sia stato salvato nel sistema dopo l'esecuzione della funzione.** ):
```
import { util } from '@aws-appsync/utils';
export function request(ctx) {
return ctx.prev.result;
}
export function response(ctx) {
ctx.result.id = util.autoId();
return ctx.result;
}
```
Abbiamo appena creato la nostra funzione **SaveUser**.
## Fase 3: Aggiungere una funzione a un risolutore di pipeline
Le nostre funzioni avrebbero dovuto essere aggiunte automaticamente al risolutore di pipeline che abbiamo appena creato. Se così non fosse, o se hai creato le funzioni tramite la pagina **Funzioni**, puoi fare clic su **Aggiungi funzione** nuovamente nella pagina del `signUp` resolver per allegarle. Aggiungi entrambe le funzioni **ValidateEmail** **e** SaveUser al resolver. la funzione **validateEmail** deve precedere quella **saveUser**. Man mano che aggiungi altre funzioni, puoi utilizzare le opzioni di **spostamento su** e **sposta giù** per riorganizzare l'ordine di esecuzione delle funzioni. Controlla le modifiche, quindi scegli **Salva**.
## Passaggio 4: Esecuzione di una query
Nella AWS AppSync console, vai alla pagina **Query**. Nell'explorer, assicurati di usare la tua mutazione. Se non lo sei, scegli `Mutation` nell'elenco a discesa, quindi scegli. `+` Inserire la query seguente:
```
mutation {
signUp(input: {email: "nadia@myvaliddomain.com", username: "nadia"}) {
id
username
}
}
```
Questo dovrebbe restituire qualcosa del tipo:
```
{
"data": {
"signUp": {
"id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
"username": "nadia"
}
}
}
```
Abbiamo quindi registrato il nostro utente convalidandone, al contempo, l'e-mail di input tramite un resolver di pipeline.