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à.
# 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.