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 risolutori di pipeline in AWS AppSync (VTL)

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 risolutori di 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.

Un resolver di pipeline è composto da due modelli di mappatura, della fase antecedente e successiva, e un elenco di funzioni. Ogni funzione ha un modello di mappatura delle richieste e delle 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. I risolutori di unità e le funzioni sono primitive che eseguono operazioni su fonti di dati. Per ulteriori informazioni, consulta la panoramica del modello di mappatura Resolver.

Passaggio 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. Nella pagina di creazione del resolver, fai clic su Azioni, quindi su Aggiorna runtime. ScegliPipeline Resolver, quindi scegliVTL, quindi scegli Aggiorna. La pagina dovrebbe ora mostrare tre sezioni: un'area di testo Prima della mappatura del modello, una sezione Funzioni e un'area di testo Dopo la mappatura del modello.

Il nostra resolver di pipeline registra un utente convalidandone l'indirizzo e-mail e, successivamente, salvandolo nel sistema. Dobbiamo quindi incapsulare la convalida dell'e-mail in una funzione validateEmail e il salvataggio dell'utente in 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 corrisponderà al seguente:

Poiché probabilmente riutilizzeremo la funzione ValidateEmail in altri resolver della 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).

PRIMA DI MAPPARE IL MODELLO:

## store email input field into a generic email key
$util.qr($ctx.stash.put("email", $ctx.args.input.email))
{}

La console fornisce un modello di mappatura passthrough predefinito che utilizzeremo:

$util.toJson($ctx.result)

Scegli Crea o Salva per aggiornare il resolver.

Fase 2: Creazione di una funzione

Dalla pagina del 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.

Nella nuova pagina delle funzioni, scegli Azioni, quindi Aggiorna runtime. ScegliVTL, quindi Aggiorna. Assicurati di aver creato un'origine dati di tipo NONE. Scegli questa origine dati nell'elenco Nome origine dati. Per il nome della funzione, inseriscivalidateEmail. Nell'area del codice della funzione, sovrascrivi tutto con questo frammento:

#set($valid = $util.matches("^[a-zA-Z0-9_.+-]+@(?:(?:[a-zA-Z0-9-]+\.)?[a-zA-Z]+\.)?(myvaliddomain)\.com", $ctx.stash.email))
#if (!$valid)
    $util.error("$ctx.stash.email is not a valid email.")
#end
{
    "payload": { "email": $util.toJson(${ctx.stash.email}) }
}

Incolla questo nel modello di mappatura delle risposte:

$util.toJson($ctx.result)

Rivedi le modifiche, quindi scegli Crea. A questo punto, la funzione validateEmail è stata creata. Ripeti questi passaggi per creare la funzione SaveUser con i seguenti modelli di mappatura di richieste e risposte (per semplicità, utilizziamo un'origine dati NONE e facciamo finta che l'utente sia stato salvato nel sistema dopo l'esecuzione della funzione. ):

Modello di mappatura della richiesta:

## $ctx.prev.result contains the signup input values. We could have also
## used $ctx.args.input.
{
    "payload": $util.toJson($ctx.prev.result)
}

Modello di mappatura della risposta:

## an id is required so let's add a unique random identifier to the output
$util.qr($ctx.result.put("id", $util.autoId()))
$util.toJson($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 pipeline resolver che abbiamo appena creato. In caso contrario, o se hai creato le funzioni tramite la pagina Funzioni, puoi fare clic su Aggiungi funzione nella pagina del resolver per allegarle. Aggiungi entrambe le funzioni ValidateEmail e SaveUser al resolver. la funzione validateEmail deve precedere quella saveUser. Man mano che aggiungete altre funzioni, potete utilizzare le opzioni sposta su e sposta giù per riorganizzare l'ordine di esecuzione delle funzioni. Rivedi le modifiche, quindi scegli Salva.

Fase 4: Esecuzione di una richiesta

Nella AWS AppSync console, vai alla pagina Query. In Explorer, assicurati di utilizzare 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
    email
  }
}

Questo dovrebbe restituire qualcosa come:

{
  "data": {
    "signUp": {
      "id": "256b6cc2-4694-46f4-a55e-8cb14cc5d7fc",
      "email": "nadia@myvaliddomain.com"
    }
  }
}

Abbiamo quindi registrato il nostro utente convalidandone, al contempo, l'e-mail di input tramite un resolver di pipeline. Un tutorial più articolato sui resolver di pipeline è disponibile alla pagina Tutorial: resolver di pipeline.