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)
Questa sezione descrive come configurare i resolver utilizzando. JavaScript La sezione Resolver tutorials (JavaScript) fornisce tutorial 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. 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.
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
-
-
Accedi a AWS Management Console e apri la AppSync console.
-
Nella APIsdashboard, scegli il tuo GraphQLAPI.
-
Nella barra laterale, scegli Schema.
-
-
Inserisci i dettagli dello schema e della fonte di dati. Per ulteriori informazioni, consulta le sezioni Progettazione dello schema e Collegamento di un'origine dati.
-
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.
-
Nella pagina Attach resolver, in Tipo di resolver, puoi scegliere tra resolver pipeline o unit. Per ulteriori informazioni su questi tipi, consulta Resolvers. 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 -
A tale scopo è possibile abilitare la memorizzazione nella cache. API Ti consigliamo di disattivare questa funzionalità per ora. Scegli Create (Crea) .
-
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
Nota
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.
-
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 suid
ed è vuota. -
Inserisci un
Function name
. -
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. 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 diPost
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 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'Scan
operazione (vedi qui 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 comeresult
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 nostrarequest
.result
Contiene il/i risultato/i 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.
-
-
Scegli Crea dopo aver finito.
-
-
Tornando alla schermata del resolver, in Funzioni, scegli il menu a discesa Aggiungi funzione e aggiungi la tua funzione all'elenco delle funzioni.
-
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
Dovrai inserire alcuni parametri per questo particolare comando:
-
api-id
I tuoiAPI. -
name
La funzione nella AWS AppSync console. -
Il
data-source-name
, o il nome dell'origine dati che verrà utilizzata dalla funzione. Deve essere già stato creato e collegato al tuo GraphQL API nel AWS AppSync servizio. -
L'
runtime
ambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essereAPPSYNC_JS
, e il runtime,1.0.0
. -
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 inCLI. 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
Dovrai inserire alcuni parametri per questo particolare comando:
-
api-id
I tuoiAPI. -
Il
type-name
, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription). -
Il
field-name
, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver. -
Il
kind
, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni dellaPIPELINE
pipeline. -
La
pipeline-config
, o la o le funzioni da collegare al resolver. Assicurati di conoscerefunctionId
i valori delle tue funzioni. L'ordine delle inserzioni è importante. -
Il
runtime
, che eraAPPSYNC_JS
(JavaScript).runtimeVersion
Attualmente è1.0.0
. -
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 inCLI. 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 ilCDK, ti consigliamo CDK di consultare la documentazione ufficiale insieme AWS AppSync al CDKriferimento.
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:
-
Direttive di importazione dei servizi
-
Codice dello schema
-
Generatore di fonti di dati
-
Codice della funzione
-
Codice resolver
Dalle sezioni Progettazione dello schema e Allegare una fonte di dati, 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'CDKapp 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 CDK l'app 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. -
import * as appsync from 'aws-cdk-lib/aws-appsync';
: Questo importa il AWS AppSync servizio. -
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';
: Importa il servizio DynamoDB. -
import { Construct } from 'constructs';
: Ne abbiamo bisogno per definire il costrutto root.
Il tipo di importazione dipende dai servizi che stai chiamando. Ti consigliamo di CDK consultare la documentazione per alcuni esempi. Lo schema nella parte superiore della pagina sarà un file separato nell'CDKapp 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 un nuovo GraphQL API utilizzando lanew
parola chiave seguita da.appsync.GraphqlApi(scope: Construct, id: string , props: GraphqlApiProps)
Il nostro ambito èthis
, l'CFNid ègraphQL-example
e i nostri oggetti di scena sonomy-first-api
(nome della API console) eschema.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 a GraphQL API 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 CFN l'id
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 CFN id lo erafunc-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
). -
Il GraphQL API che abbiamo creato in precedenza ()
add_api
. -
L'origine dei dati; questo è il punto in cui colleghiamo l'origine dati al API valore GraphQL, quindi la colleghiamo alla funzione. Prendiamo la tabella che abbiamo creato (
add_ddb_table
) e la colleghiamo a GraphQL API (add_api
) usando uno deiGraphqlApi
metodi (addDynamoDbDataSource
). Il valore id (table-for-posts
) è il nome della fonte di dati nella AWS AppSync console. Per un elenco di metodi specifici della fonte, consulta le pagine seguenti: -
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 _JS 1.0.0. Nota che questa è attualmente l'unica versione disponibile per _JS. APPSYNC
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 CFN id lo erapipeline-resolver-get-posts
e i nostri oggetti di scena contenevano i dettagli effettivi della funzione. All'interno degli oggetti di scena, abbiamo incluso:-
Il GraphQL API 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 ilQuery
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 _JS 1.0.0. Nota che questa è attualmente l'unica versione disponibile per _JS. APPSYNC
-
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
-
-
Accedi a AWS Management Console e apri la console. AppSync
-
Nella APIsdashboard, scegli il tuo GraphQLAPI.
-
Nella barra laterale, scegli Schema.
-
-
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 suid
ed è vuota. -
Nella pagina Allega resolver, in Tipo di risolutore, scegli.
pipeline resolvers
Come promemoria, puoi trovare ulteriori informazioni sui resolver qui. Per Resolver runtime, scegli di abilitare il runtime.APPSYNC_JS
JavaScript -
A tale scopo è possibile abilitare la memorizzazione nella cache. API Ti consigliamo di disattivare questa funzionalità per ora. Scegli Create (Crea) .
-
Scegli Aggiungi funzione, quindi scegli Crea nuova funzione. In alternativa, potresti invece visualizzare un pulsante Crea funzione tra cui scegliere.
-
Scegli l'origine dati. Questa dovrebbe essere la fonte di cui manipolerai i dati con la mutazione.
-
Inserisci un.
Function name
-
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 nuovoPost
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 unPutItem
comando, che è un'operazione DynamoDB integrata (vedi qui o qui per alcuni esempi). IlPutItem
comando aggiunge unPost
oggetto alla nostra tabella DynamoDB prendendo il valore dellakey
partizione (generato automaticamenteutil.autoid()
da)attributes
e dall'input dell'argomento di contesto (questi sono i valori che passeremo nella nostra richiesta). Gli argomentikey
èid
eattributes
sono glidate
etitle
i campi. Sono entrambi preformattati tramite l'util.dynamodb.toMapValues
helper per funzionare con la tabella DynamoDB. -
response
: La risposta accetta il contesto aggiornato e restituisce il risultato del gestore della richiesta.
-
-
Scegli Crea dopo aver finito.
-
-
Tornando alla schermata del resolver, in Funzioni, scegli il menu a discesa Aggiungi funzione e aggiungi la tua funzione all'elenco delle funzioni.
-
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
Dovrai inserire alcuni parametri per questo particolare comando:
-
api-id
I tuoiAPI. -
name
La funzione nella AWS AppSync console. -
Il
data-source-name
, o il nome dell'origine dati che verrà utilizzata dalla funzione. Deve essere già stato creato e collegato al tuo GraphQL API nel AWS AppSync servizio. -
L'
runtime
ambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essereAPPSYNC_JS
, e il runtime,1.0.0
. -
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 inCLI. 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
Dovrai inserire alcuni parametri per questo particolare comando:
-
api-id
I tuoiAPI. -
Il
type-name
, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription). -
Il
field-name
, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver. -
Il
kind
, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni dellaPIPELINE
pipeline. -
La
pipeline-config
, o la o le funzioni da collegare al resolver. Assicurati di conoscerefunctionId
i valori delle tue funzioni. L'ordine delle inserzioni è importante. -
Il
runtime
, che eraAPPSYNC_JS
(JavaScript).runtimeVersion
Attualmente è1.0.0
. -
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 inCLI. 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 ilCDK, ti consigliamo CDK di consultare la documentazione ufficiale insieme AWS AppSync al CDKriferimento.
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 apportare una mutazione, supponendo che tu faccia parte dello stesso progetto, puoi 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'CFNid in
func-add-post
e il nome inadd_posts_func_1
per riflettere il fatto che stiamo aggiungendoPosts
alla tabella. Nell'origine dati, abbiamo creato una nuova associazione alla nostra table (add_ddb_table
) nella AWS AppSync consoletable-for-posts-2
perché iladdDynamoDbDataSource
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 astable-for-posts
e una per la mutazione astable-for-posts-2
. Il codice è stato modificato per aggiungere un valorePost
generando automaticamente il suoid
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 aggiungendoPosts
alla tabella. Per riflettere la mutazione nello schema, il nome del tipo è stato cambiato inMutation
, 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 e Monitoring and logging.
Resolver avanzati
Se stai seguendo la sezione opzionale sull'impaginazione in Progettazione dello 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.