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

1. Accedi a AWS Management Console e apri la AppSync console.

   1. Nella APIs dashboard, scegli la tua API GraphQL.

   2. Nella barra laterale, scegli Schema.

2. 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.

3. 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.

4. 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

5. Puoi abilitare la memorizzazione nella cache per questa API. Ti consigliamo di disattivare questa funzionalità per ora. Scegli Create (Crea) .

6. 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

   Nel nostro esempio, lasceremo la richiesta vuota e la risposta impostata per restituire l'ultima fonte di dati risultante dal contesto:

   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 pergetPost, 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.

   2. Inserisci unFunction name.

   3. 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 agetPost, 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 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'Scanoperazione (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 come result contenitore prima di essere passato al gestore delle risposte. requestViene 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. ctxsi riferisce all'oggetto contestuale. prevsi riferisce all'operazione precedente nella pipeline, che era la nostrarequest. resultContiene 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.

   4. Scegli Crea dopo aver finito.

7. Tornando alla schermata del resolver, in Funzioni, scegli il menu a discesa Aggiungi funzione e aggiungi la tua funzione all'elenco delle funzioni.

8. 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:

  1. La api-id della tua API.

  2. nameLa funzione nella AWS AppSync console.

  3. Ildata-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.

  4. L'runtimeambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essereAPPSYNC_JS, e il runtime,1.0.0.

  5. 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

  Dovrai inserire alcuni parametri per questo particolare comando:

  1. La api-id della tua API.

  2. Iltype-name, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription).

  3. Ilfield-name, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver.

  4. Ilkind, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni della PIPELINE pipeline.

  5. Lapipeline-config, o la o le funzioni da collegare al resolver. Assicurati di conoscere functionId i valori delle tue funzioni. L'ordine delle inserzioni è importante.

  6. Ilruntime, che era APPSYNC_JS (JavaScript). runtimeVersionAttualmente è1.0.0.

  7. Ilcode, 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 CDK.

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

2. Codice dello schema

3. Generatore di fonti di dati

4. Codice della funzione

5. 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'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.

• 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 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'ambitoadd_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 erathis, 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 (addDynamoDbDataSource). 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

  • EventBridgeDataSource

  • HttpDataSource

  • LambdaDataSource

  • NoneDataSource

  • OpenSearchDataSource

  • RdsDataSource

• 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 APPSYNC_JS.

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 erathis, 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 valoreQuery.

• 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_JS 1.0.0. Nota che questa è attualmente l'unica versione disponibile per APPSYNC_JS.

• 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'Scanoperazione 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 AWS Management Console e apri la console. AppSync

   1. Nella APIs dashboard, scegli la tua API GraphQL.

   2. Nella barra laterale, scegli Schema.

2. Nella sezione Resolver e nel tipo di mutazione, scegli Allega accanto al tuo campo.

   Nota

   Nel nostro esempio, stiamo collegando un resolver percreatePost, 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.

3. 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

4. Puoi abilitare la memorizzazione nella cache per questa API. Ti consigliamo di disattivare questa funzionalità per ora. Scegli Create (Crea) .

5. 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.

   2. Inserisci un. Function name

   3. 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

      createPoststa 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 PutItemcomando, che è un'operazione DynamoDB integrata (vedi qui o 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'util.dynamodb.toMapValueshelper per funzionare con la tabella DynamoDB.

      • response: La risposta accetta il contesto aggiornato e restituisce il risultato del gestore della richiesta.

   4. Scegli Crea dopo aver finito.

6. Tornando alla schermata del resolver, in Funzioni, scegli il menu a discesa Aggiungi funzione e aggiungi la tua funzione all'elenco delle funzioni.

7. 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:

  1. La api-id della tua API.

  2. nameLa funzione nella AWS AppSync console.

  3. Ildata-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.

  4. L'runtimeambiente o e il linguaggio della funzione. Perché JavaScript, il nome deve essereAPPSYNC_JS, e il runtime,1.0.0.

  5. 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

  Dovrai inserire alcuni parametri per questo particolare comando:

  1. La api-id della tua API.

  2. Iltype-name, o il tipo di oggetto speciale nel tuo schema (Query, Mutation, Subscription).

  3. Ilfield-name, o l'operazione di campo all'interno del tipo di oggetto speciale a cui si desidera collegare il resolver.

  4. Ilkind, che specifica un'unità o un resolver di pipeline. Impostalo per abilitare le funzioni della PIPELINE pipeline.

  5. Lapipeline-config, o la o le funzioni da collegare al resolver. Assicurati di conoscere functionId i valori delle tue funzioni. L'ordine delle inserzioni è importante.

  6. Ilruntime, che era APPSYNC_JS (JavaScript). runtimeVersionAttualmente è1.0.0.

  7. Ilcode, 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 CDK.

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 astable-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 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.