Creazione di una semplice applicazione post utilizzando i resolver DynamoDB JavaScript - AWS AppSync GraphQL
Creazione dell'API GraphQLDefinizione di un'API post di baseConfigurazione della tabella Amazon DynamoDBConfigurazione di un resolver AddPost (Amazon DynamoDB) PutItemConfigurazione del resolver GetPost (Amazon DynamoDB) GetItemCreare una mutazione UpdatePost (Amazon DynamoDB) UpdateItemCrea mutazioni di voto (Amazon DynamoDB UpdateItem)Configurazione di un resolver DeletePost (Amazon DynamoDB) DeleteItemConfigurazione di un resolver AllPost (Amazon DynamoDB Scan)Configurazione di un allPostsBy Author resolver (Amazon DynamoDB Query)Utilizzo dei setConclusioni

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 una semplice applicazione post utilizzando i resolver DynamoDB JavaScript

In questo tutorial, importerai le tue tabelle Amazon DynamoDB e le AWS AppSync collegherai per creare un'API GraphQL completamente funzionale JavaScript utilizzando resolver di pipeline che puoi sfruttare nella tua applicazione.

Utilizzerai la AWS AppSync console per effettuare il provisioning delle tue risorse Amazon DynamoDB, creare i tuoi resolver e collegarli alle tue fonti di dati. Potrai anche leggere e scrivere sul tuo database Amazon DynamoDB tramite istruzioni GraphQL e sottoscrivere dati in tempo reale.

Esistono passaggi specifici che devono essere completati per tradurre le istruzioni GraphQL nelle operazioni di Amazon DynamoDB e per ritradurre le risposte in GraphQL. Questo tutorial descrive il processo di configurazione attraverso diversi scenari e modelli di accesso ai dati reali.

Creazione dell'API GraphQL

Per creare un'API GraphQL in AWS AppSync

  1. Apri la AppSync console e scegli Crea API.

  2. Seleziona Design da zero e scegli Avanti.

  3. Assegna un nome alla tua APIPostTutorialAPI, quindi scegli Avanti. Passa alla pagina di revisione mantenendo le altre opzioni impostate sui valori predefiniti e scegliCreate.

La AWS AppSync console crea una nuova API GraphQL per te. Per impostazione predefinita, utilizza la modalità di autenticazione tramite chiave API. Puoi usare la console per configurare ulteriormente l'API GraphQL ed eseguire query sull'API per le parti restanti di questo tutorial.

Definizione di un'API post di base

Ora che hai la tua API GraphQL, puoi configurare uno schema di base che consenta la creazione, il recupero e l'eliminazione di base dei dati post.

Per aggiungere dati allo schema

  1. Nella tua API, scegli la scheda Schema.

  2. Creeremo uno schema che definisce un Post tipo e un'operazione addPost per aggiungere e ottenere Post oggetti. Nel riquadro Schema, sostituisci il contenuto con il seguente codice:

    schema {
    query: Query
    mutation: Mutation
}

type Query {
    getPost(id: ID): Post
}

type Mutation {
    addPost(
        id: ID!
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

type Post {
    id: ID!
    author: String
    title: String
    content: String
    url: String
    ups: Int!
    downs: Int!
    version: Int!
}

  3. Scegli Save Scheme (Salva schema).

Configurazione della tabella Amazon DynamoDB

La AWS AppSync console può aiutarti a fornire le AWS risorse necessarie per archiviare le tue risorse in una tabella Amazon DynamoDB. In questo passaggio, creerai una tabella Amazon DynamoDB per archiviare i tuoi post. Inoltre, configurerai un indice secondario che utilizzeremo in seguito.

Per creare la tua tabella Amazon DynamoDB

  1. Nella pagina Schema, scegli Crea risorse.

  2. Scegli Usa il tipo esistente, quindi scegli il Post tipo.

  3. Nella sezione Indici aggiuntivi, scegli Aggiungi indice.

  4. Assegna un nome all'indice. author-index

  5. Imposta Primary key a author e la Sort chiave aNone.

  6. Disabilita la generazione automatica di GraphQL. In questo esempio, creeremo noi stessi il resolver.

  7. Scegli Create (Crea) .

Ora hai una nuova fonte di dati chiamataPostTable, che puoi vedere visitando Fonti di dati nella scheda laterale. Utilizzerai questa fonte di dati per collegare le tue query e mutazioni alla tua tabella Amazon DynamoDB.

Configurazione di un resolver AddPost (Amazon DynamoDB) PutItem

Ora che conosci AWS AppSync la tabella Amazon DynamoDB, puoi collegarla a singole query e mutazioni definendo i resolver. Il primo resolver che crei è il resolver di addPost pipeline utilizzato JavaScript, che ti consente di creare un post nella tua tabella Amazon DynamoDB. Un risolutore di pipeline ha i seguenti componenti:

  • Posizione nello schema GraphQL per collegare il resolver. In questo caso, stai configurando un resolver nel campo createPost nel tipo Mutation. Questo resolver verrà richiamato quando il chiamante chiama mutation. { addPost(...){...} }

  • Origine dati da usare per il resolver. In questo caso, si desidera utilizzare l'origine dati DynamoDB definita in precedenza, in modo da poter aggiungere voci nella tabella DynamoDB. post-table-for-tutorial

  • Il gestore delle richieste. Il gestore delle richieste è una funzione che gestisce la richiesta in entrata dal chiamante e la traduce in istruzioni da AWS AppSync eseguire su DynamoDB.

  • Il gestore delle risposte. Il compito del gestore delle risposte è gestire la risposta da DynamoDB e tradurla nuovamente in qualcosa che GraphQL si aspetta. Questo è utile se la forma dei dati in DynamoDB è diversa rispetto al tipo Post in GraphQL, ma in questo caso hanno la stessa forma e di conseguenza puoi semplicemente passare i dati.

Per configurare il resolver

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Resolver, trova il addPost campo sotto il Mutation tipo, quindi scegli Allega.

  3. Scegli la tua fonte di dati, quindi scegli Crea.

  4. Nel tuo editor di codice, sostituisci il codice con questo frammento:

    import { util } from '@aws-appsync/utils'
import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	const item = { ...ctx.arguments, ups: 1, downs: 0, version: 1 }
	const key = { id: ctx.args.id ?? util.autoId() }
	return ddb.put({ key, item })
}

export function response(ctx) {
	return ctx.result
}

  5. Seleziona Salva.

Nota

In questo codice, si utilizzano gli utils del modulo DynamoDB che consentono di creare facilmente richieste DynamoDB.

AWS AppSync viene fornito con un'utilità per la generazione automatica di ID chiamatautil.autoId(), che viene utilizzata per generare un ID per il nuovo post. Se non specifichi un ID, l'utilità lo genererà automaticamente per te.

const key = { id: ctx.args.id ?? util.autoId() }

Per ulteriori informazioni sulle utilità disponibili per JavaScript, consulta Funzionalità JavaScript di runtime per resolver e funzioni.

Chiama l'API per aggiungere un post

Ora che il resolver è stato configurato, AWS AppSync puoi tradurre una addPost mutazione in entrata in un'operazione Amazon DynamoDB. PutItem Puoi ora eseguire una mutazione per inserire contenuto nella tabella.

Per eseguire l'operazione

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione:

    mutation addPost {
  addPost(
    id: 123,
    author: "AUTHORNAME"
    title: "Our first post!"
    content: "This is our first post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. addPost I risultati del post appena creato dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

La seguente spiegazione mostra cosa è successo:

  1. AWS AppSync ha ricevuto una richiesta di addPost mutazione.

  2. AWS AppSync esegue il gestore delle richieste del resolver. La ddb.put funzione crea una PutItem richiesta simile alla seguente:

    {
  operation: 'PutItem',
  key: { id: { S: '123' } },
  attributeValues: {
    downs: { N: 0 },
    author: { S: 'AUTHORNAME' },
    ups: { N: 1 },
    title: { S: 'Our first post!' },
    version: { N: 1 },
    content: { S: 'This is our first post.' },
    url: { S: 'https://aws.amazon.com/appsync/' }
  }
}

  3. AWS AppSync utilizza questo valore per generare ed eseguire una richiesta Amazon PutItem DynamoDB.

  4. AWS AppSync ha preso i risultati della PutItem richiesta e li ha riconvertiti in tipi GraphQL.

    {
    "id" : "123",
    "author": "AUTHORNAME",
    "title": "Our first post!",
    "content": "This is our first post.",
    "url": "https://aws.amazon.com/appsync/",
    "ups" : 1,
    "downs" : 0,
    "version" : 1
}

  5. Il gestore della risposta restituisce immediatamente il risultato ()return ctx.result.

  6. Il risultato finale è visibile nella risposta GraphQL.

Configurazione del resolver GetPost (Amazon DynamoDB) GetItem

Ora che sei in grado di aggiungere dati alla tabella Amazon DynamoDB, devi configurare getPost la query in modo che possa recuperare i dati dalla tabella. A questo scopo, devi configurare un altro resolver.

Per aggiungere il tuo resolver

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Resolver a destra, trova il getPost campo relativo al Query tipo, quindi scegli Allega.

  3. Scegli la tua fonte di dati, quindi scegli Crea.

  4. Nell'editor di codice, sostituisci il codice con questo frammento:

    import * as ddb from '@aws-appsync/utils/dynamodb'
	
export function request(ctx) {
	return ddb.get({ key: { id: ctx.args.id } })
}

export const response = (ctx) => ctx.result

  5. Salva il resolver.

Nota

In questo resolver, utilizziamo un'espressione della funzione freccia per il gestore delle risposte.

Chiama l'API per ricevere un post

Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una getPost query in entrata in un'operazione Amazon DynamoDB. GetItem Puoi ora eseguire una query per recuperare il post creato prima.

Per eseguire la tua query

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi il codice seguente e usa l'id che hai copiato dopo aver creato il post:

    query getPost {
  getPost(id: "123") {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. getPost I risultati del post appena creato dovrebbero apparire nel riquadro Risultati a destra del riquadro Query.

  4. Il post recuperato da Amazon DynamoDB dovrebbe apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "getPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our first post!",
      "content": "This is our first post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

In alternativa, prendi il seguente esempio:

query getPost {
  getPost(id: "123") {
    id
    author
    title
  }
}

Se la tua getPost query richiede solo ilid, e authortitle, puoi modificare la funzione di richiesta per utilizzare le espressioni di proiezione per specificare solo gli attributi che desideri dalla tua tabella DynamoDB per evitare trasferimenti di dati non necessari da DynamoDB a. AWS AppSync Ad esempio, la funzione di richiesta può essere simile allo snippet riportato di seguito:

import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	return ddb.get({
		key: { id: ctx.args.id },
		projection: ['author', 'id', 'title'],
	})
}

export const response = (ctx) => ctx.result

Puoi anche usare un selectionSetListwith getPost per rappresentare: expression

import * as ddb from '@aws-appsync/utils/dynamodb'

export function request(ctx) {
	const projection = ctx.info.selectionSetList.map((field) => field.replace('/', '.'))
	return ddb.get({ key: { id: ctx.args.id }, projection })
}

export const response = (ctx) => ctx.result

Creare una mutazione UpdatePost (Amazon DynamoDB) UpdateItem

Finora puoi creare e recuperare Post oggetti in Amazon DynamoDB. Successivamente, imposterai una nuova mutazione per aggiornare un oggetto. Rispetto alla addPost mutazione che richiede la specificazione di tutti i campi, questa mutazione consente di specificare solo i campi che si desidera modificare. Ha inoltre introdotto un nuovo expectedVersion argomento che consente di specificare la versione che si desidera modificare. Imposterete una condizione che assicurerà che stiate modificando la versione più recente dell'oggetto. Potrai farlo utilizzando UpdateItem Amazon DynamoDB operation.sc

Per aggiornare il resolver

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Schema, modificare il tipo Mutation per aggiungere una nuova mutazione updatePost come segue:

    type Mutation {
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    
    addPost(
        id: ID
        author: String!
        title: String!
        content: String!
        url: String!
    ): Post!
}

  3. Scegli Save Scheme (Salva schema).

  4. Nel riquadro Resolver a destra, trova il updatePost campo appena creato relativo al Mutation tipo, quindi scegli Allega. Crea il tuo nuovo resolver usando lo snippet qui sotto:

    import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { id, expectedVersion, ...rest } = ctx.args;
  const values = Object.entries(rest).reduce((obj, [key, value]) => {
    obj[key] = value ?? ddb.operations.remove();
    return obj;
  }, {});

  return ddb.update({
    key: { id },
    condition: { version: { eq: expectedVersion } },
    update: { ...values, version: ddb.operations.increment(1) },
  });
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    util.appendError(error.message, error.type);
  }
  return result;

  5. Salva tutte le modifiche apportate.

Questo resolver viene utilizzato ddb.update per creare una richiesta Amazon DynamoDB. UpdateItem Invece di scrivere l'intero articolo, stai semplicemente chiedendo ad Amazon DynamoDB di aggiornare determinati attributi. Questa operazione viene eseguita utilizzando le espressioni di aggiornamento di Amazon DynamoDB.

La ddb.update funzione accetta una chiave e un oggetto di aggiornamento come argomenti. Quindi, si controllano i valori degli argomenti in entrata. Quando un valore è impostato sunull, utilizzate l'operazione remove DynamoDB per segnalare che il valore deve essere rimosso dall'elemento DynamoDB.

C'è anche una nuova sezione. condition Un'espressione di condizione consente di indicare AWS AppSync ad Amazon DynamoDB se la richiesta deve avere successo o meno in base allo stato dell'oggetto già in Amazon DynamoDB prima dell'esecuzione dell'operazione. In questo caso, vuoi che la UpdateItem richiesta abbia esito positivo solo se il version campo dell'elemento attualmente in Amazon DynamoDB corrisponde expectedVersion esattamente all'argomento. Quando l'elemento viene aggiornato, vogliamo incrementare il valore di. version Questo è facile da fare con la funzione increment operativa.

Per ulteriori informazioni sulle espressioni condizionali, consulta la documentazione sulle espressioni di condizione.

Per maggiori informazioni sulla UpdateItem richiesta, consulta la UpdateItemdocumentazione e la documentazione del modulo DynamoDB.

Per ulteriori informazioni su come scrivere espressioni di aggiornamento, consulta la documentazione di UpdateExpressionsDynamoDB.

Chiama l'API per aggiornare un post

Proviamo ad aggiornare l'Postoggetto con il nuovo resolver.

Per aggiornare l'oggetto

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione. Dovrai anche aggiornare l'idargomento al valore annotato in precedenza:

    mutation updatePost {
  updatePost(
    id:123
    title: "An empty story"
    content: null
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegliupdatePost.

  4. Il post aggiornato in Amazon DynamoDB dovrebbe apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "updatePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 2
    }
  }
}

In questa richiesta, hai chiesto ad Amazon DynamoDB di aggiornare title solo i campi AWS AppSync and. content Tutti gli altri campi sono stati lasciati soli (a parte l'incremento del version campo). Hai impostato l'titleattributo su un nuovo valore e rimosso l'contentattributo dal post. I campi author, url, ups e downs sono stati lasciati invariati. Prova a eseguire nuovamente la richiesta di mutazione lasciando la richiesta esattamente com'è. Noterai una risposta simile alla seguente:

{
  "data": {
    "updatePost": null
  },
  "errors": [
    {
      "path": [
        "updatePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 1RR3QN5F35CS8IV5VR4OQO9NNBVV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

La richiesta fallisce perché l'espressione della condizione restituisce: false

  1. La prima volta che hai eseguito la richiesta, il valore del version campo del post in Amazon DynamoDB 1 era corrispondente all'argomento. expectedVersion La richiesta è riuscita, il che significa che il version campo è stato incrementato in Amazon DynamoDB a. 2

  2. La seconda volta che hai eseguito la richiesta, il valore del version campo del post in Amazon DynamoDB 2 era, che non corrispondeva all'argomento. expectedVersion

Questo modello viene in genere chiamato blocco ottimistico.

Crea mutazioni di voto (Amazon DynamoDB UpdateItem)

Il Post tipo contiene downs campi per consentire la registrazione di voti positivi ups e negativi. Tuttavia, al momento, l'API non ci consente di fare nulla con loro. Aggiungiamo una mutazione per consentirci di votare positivamente e negativamente i post.

Per aggiungere la tua mutazione

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Schema, modifica il Mutation tipo e aggiungi l'DIRECTIONenum per aggiungere nuove mutazioni di voto:

    type Mutation {
    vote(id: ID!, direction: DIRECTION!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        id: ID,
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

enum DIRECTION {
  UP
  DOWN
}

  3. Scegli Save Scheme (Salva schema).

  4. Nel riquadro Resolver a destra, individuate il vote campo appena creato relativo al Mutation tipo, quindi scegliete Allega. Crea un nuovo resolver creando e sostituendo il codice con il seguente frammento:

    import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const field = ctx.args.direction === 'UP' ? 'ups' : 'downs';
  return ddb.update({
    key: { id: ctx.args.id },
    update: {
      [field]: ddb.operations.increment(1),
      version: ddb.operations.increment(1),
    },
  });
}

export const response = (ctx) => ctx.result;

  5. Salva tutte le modifiche apportate.

Chiama l'API per dare un voto positivo o negativo a un post

Ora che i nuovi resolver sono stati configurati, AWS AppSync sa come tradurre una modifica upvotePost o una downvote mutazione in entrata in un'operazione Amazon DynamoDB. UpdateItem Ora puoi eseguire mutazioni per assegnare voti positivi e voti negativi al post creato prima.

Per eseguire la tua mutazione

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione. Dovrai anche aggiornare l'idargomento al valore annotato in precedenza:

    mutation votePost {
  vote(id:123, direction: UP) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi sceglivotePost.

  4. Il post aggiornato in Amazon DynamoDB dovrebbe apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "vote": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 0,
      "version": 4
    }
  }
}

  5. Scegli Esegui ancora un paio di volte. Dovresti vedere i version campi ups and incrementare 1 ogni volta che esegui la query.

  6. Modificate la query per chiamarla con un'altraDIRECTION.

    mutation votePost {
  vote(id:123, direction: DOWN) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  7. Scegli Esegui (il pulsante di riproduzione arancione), quindi sceglivotePost.

    Questa volta, dovresti vedere i version campi downs and incrementarsi 1 ogni volta che esegui la query.

Configurazione di un resolver DeletePost (Amazon DynamoDB) DeleteItem

Successivamente, ti consigliamo di creare una mutazione per eliminare un post. Potrai farlo utilizzando l'operazione DeleteItem Amazon DynamoDB.

Per aggiungere la tua mutazione

  1. Nel tuo schema, scegli la scheda Schema.

  2. Nel riquadro Schema, modifica il Mutation tipo per aggiungere una nuova deletePost mutazione:

    type Mutation {
    deletePost(id: ID!, expectedVersion: Int): Post
    vote(id: ID!, direction: DIRECTION!): Post
    updatePost(
        id: ID!,
        author: String,
        title: String,
        content: String,
        url: String,
        expectedVersion: Int!
    ): Post
    addPost(
        id: ID
        author: String!,
        title: String!,
        content: String!,
        url: String!
    ): Post!
}

  3. Questa volta, hai reso il expectedVersion campo facoltativo. Quindi, scegli Salva schema.

  4. Nel riquadro Resolver a destra, trova il delete campo appena creato nel Mutation tipo, quindi scegli Allega. Crea un nuovo resolver utilizzando il seguente codice:

    import { util } from '@aws-appsync/utils'

import { util } from '@aws-appsync/utils';
import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  let condition = null;
  if (ctx.args.expectedVersion) {
    condition = {
      or: [
        { id: { attributeExists: false } },
        { version: { eq: ctx.args.expectedVersion } },
      ],
    };
  }
  return ddb.remove({ key: { id: ctx.args.id }, condition });
}

export function response(ctx) {
  const { error, result } = ctx;
  if (error) {
    util.appendError(error.message, error.type);
  }
  return result;
}
    Nota

    L'expectedVersionargomento è un argomento facoltativo. Se il chiamante imposta un expectedVersion argomento nella richiesta, il gestore della richiesta aggiunge una condizione che consente alla DeleteItem richiesta di avere successo solo se l'elemento è già stato eliminato o se l'versionattributo del post in Amazon DynamoDB corrisponde esattamente a. expectedVersion Se non viene inserito, nessuna espressione di condizione viene specificata nella richiesta DeleteItem. Ha successo indipendentemente dal valore o dall'esistenza version o meno dell'elemento in Amazon DynamoDB.

    Anche se stai eliminando un articolo, puoi restituire l'elemento che è stato eliminato, se non lo era già.

Per maggiori informazioni sulla DeleteItem richiesta, consulta la DeleteItemdocumentazione.

Chiama l'API per eliminare un post

Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una delete mutazione in entrata in un'operazione Amazon DynamoDB. DeleteItem Puoi ora eseguire una mutazione per eliminare qualcosa nella tabella.

Per eseguire la tua mutazione

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione. Dovrai anche aggiornare l'idargomento al valore annotato in precedenza:

    mutation deletePost {
  deletePost(id:123) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi sceglideletePost.

  4. Il post viene eliminato da Amazon DynamoDB. Tieni presente che AWS AppSync restituisce il valore dell'elemento che è stato eliminato da Amazon DynamoDB, che dovrebbe apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "deletePost": {
      "id": "123",
      "author": "A new author",
      "title": "An empty story",
      "content": null,
      "url": "https://aws.amazon.com/appsync/",
      "ups": 6,
      "downs": 4,
      "version": 12
    }
  }
}

  5. Il valore viene restituito solo se questa chiamata a deletePost è quella che lo elimina effettivamente da Amazon DynamoDB. Scegli nuovamente Esegui.

  6. La chiamata riesce ancora, ma non viene restituito alcun valore:

    {
  "data": {
    "deletePost": null
  }
}

  7. Ora, proviamo a eliminare un post, ma questa volta specificando un. expectedValue Innanzitutto, devi creare un nuovo post perché hai appena eliminato quello con cui hai lavorato finora.

  8. Nel riquadro Query, aggiungi la seguente mutazione:

    mutation addPost {
  addPost(
    id:123
    author: "AUTHORNAME"
    title: "Our second post!"
    content: "A new post."
    url: "https://aws.amazon.com/appsync/"
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  9. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. addPost

  10. I risultati del post appena creato dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. Registra id l'oggetto appena creato perché ti servirà in un attimo. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "addPost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

  11. Ora, proviamo a eliminare quel post con un valore illegale per ExpectedVersion. Nel riquadro Query, aggiungi la seguente mutazione. Dovrai anche aggiornare l'idargomento al valore annotato in precedenza:

    mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 9999
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  12. Scegli Esegui (il pulsante arancione di riproduzione), quindi sceglideletePost. Viene restituito il seguente risultato:

    {
  "data": {
    "deletePost": null
  },
  "errors": [
    {
      "path": [
        "deletePost"
      ],
      "data": null,
      "errorType": "DynamoDB:ConditionalCheckFailedException",
      "errorInfo": null,
      "locations": [
        {
          "line": 2,
          "column": 3,
          "sourceName": null
        }
      ],
      "message": "The conditional request failed (Service: DynamoDb, Status Code: 400, Request ID: 7083O037M1FTFRK038A4CI9H43VV4KQNSO5AEMVJF66Q9ASUAAJG)"
    }
  ]
}

  13. La richiesta non è riuscita perché l'espressione della condizione restituisce. false Il valore version del post in Amazon DynamoDB non corrisponde a quello specificato expectedValue negli argomenti. Il valore corrente dell'oggetto viene restituito nel campo data nella sezione errors della risposta GraphQL. Riprova la richiesta, correggendo il valore di expectedVersion: 

    mutation deletePost {
  deletePost(
    id:123
    expectedVersion: 1
  ) {
    id
    author
    title
    content
    url
    ups
    downs
    version
  }
}

  14. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. deletePost

    Questa volta la richiesta ha esito positivo e viene restituito il valore che è stato eliminato da Amazon DynamoDB:

    {
  "data": {
    "deletePost": {
      "id": "123",
      "author": "AUTHORNAME",
      "title": "Our second post!",
      "content": "A new post.",
      "url": "https://aws.amazon.com/appsync/",
      "ups": 1,
      "downs": 0,
      "version": 1
    }
  }
}

  15. Scegli di nuovo Esegui. La chiamata riesce ancora, ma questa volta non viene restituito alcun valore perché il post è già stato eliminato in Amazon DynamoDB.

    { "data": { "deletePost": null } }

Configurazione di un resolver AllPost (Amazon DynamoDB Scan)

Finora, l'API è utile solo se conosci ogni post che vuoi guardare. id Aggiungiamo ora un nuovo resolver che restituisce tutti i post nella tabella.

Per aggiungere la tua mutazione

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Schema, modificare il tipo Query per aggiungere una nuova query allPost come segue:

    type Query {
    allPost(limit: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

  3. Aggiungi un nuovo tipo PaginationPosts:

    type PaginatedPosts {
    posts: [Post!]!
    nextToken: String
}

  4. Scegli Save Scheme (Salva schema).

  5. Nel riquadro Resolver a destra, trova il allPost campo appena creato nel Query tipo, quindi scegli Allega. Crea un nuovo resolver con il seguente codice:

    import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken } = ctx.arguments;
  return ddb.scan({ limit, nextToken });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

    Il gestore delle richieste di questo resolver prevede due argomenti opzionali:

    • limit- Speciifica il numero massimo di elementi da restituire in una singola chiamata.

    • nextToken- Utilizzato per recuperare il prossimo set di risultati (mostreremo da dove nextToken proviene il valore di in seguito).

  6. Salva tutte le modifiche apportate al tuo resolver.

Per ulteriori informazioni sulla Scan richiesta, consulta la documentazione di riferimento di Scan.

Chiama l'API per scansionare tutti i post

Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una allPost query in entrata in un'operazione Amazon DynamoDB. Scan Puoi ora analizzare la tabella per recuperare tutti i post. Prima di provare, devi immettere nella tabella alcuni dati, perché hai eliminato tutti quelli usati finora.

Per aggiungere e interrogare dati

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione:

    mutation addPost {
  post1: addPost(id:1 author: "AUTHORNAME" title: "A series of posts, Volume 1" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post2: addPost(id:2 author: "AUTHORNAME" title: "A series of posts, Volume 2" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post3: addPost(id:3 author: "AUTHORNAME" title: "A series of posts, Volume 3" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post4: addPost(id:4 author: "AUTHORNAME" title: "A series of posts, Volume 4" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post5: addPost(id:5 author: "AUTHORNAME" title: "A series of posts, Volume 5" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post6: addPost(id:6 author: "AUTHORNAME" title: "A series of posts, Volume 6" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post7: addPost(id:7 author: "AUTHORNAME" title: "A series of posts, Volume 7" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post8: addPost(id:8 author: "AUTHORNAME" title: "A series of posts, Volume 8" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
  post9: addPost(id:9 author: "AUTHORNAME" title: "A series of posts, Volume 9" content: "Some content" url: "https://aws.amazon.com/appsync/" ) { title }
}

  3. Scegli Esegui (il pulsante di riproduzione arancione).

  4. Analizziamo ora la tabella, restituendo cinque risultati per volta. Nel riquadro Interrogazioni, aggiungi la seguente interrogazione:

    query allPost {
  allPost(limit: 5) {
    posts {
      id
      title
    }
    nextToken
  }
}

  5. Scegli Esegui (il pulsante di riproduzione arancione), quindi scegliallPost.

    I primi cinque post dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        },
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        }
      ],
      "nextToken": "<token>"
    }
  }
}

  6. Hai ricevuto cinque risultati e uno nextToken che puoi utilizzare per ottenere il prossimo set di risultati. Aggiornare la query allPost in modo da includere nextToken dal set precedente di risultati: 

    query allPost {
  allPost(
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      author
    }
    nextToken
  }
}

  7. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegliallPost.

    I quattro post rimanenti dovrebbero apparire nel riquadro Risultati a destra del riquadro Interrogazioni. Non c'è nessuno nextToken in questo set di risultati perché hai sfogliato tutti e nove i post senza che ne rimanga nessuno. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPost": {
      "posts": [
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        }
      ],
      "nextToken": null
    }
  }
}

Configurazione di un allPostsBy Author resolver (Amazon DynamoDB Query)

Oltre a scansionare Amazon DynamoDB per tutti i post, puoi anche interrogare Amazon DynamoDB per recuperare i post creati da un autore specifico. La tabella Amazon DynamoDB creata in precedenza contiene già GlobalSecondaryIndex una author-index chiamata che puoi usare con un'operazione Amazon DynamoDB per recuperare tutti i Query post creati da un autore specifico.

Per aggiungere la tua query

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Schema, modificare il tipo Query per aggiungere una nuova query allPostsByAuthor come segue:

    type Query {
    allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
    allPost(limit: Int, nextToken: String): PaginatedPosts!
    getPost(id: ID): Post
}

    Tieni presente che utilizza lo stesso PaginatedPosts tipo che hai usato con la allPost query.

  3. Scegli Save Scheme (Salva schema).

  4. Nel riquadro Resolver a destra, individuate il allPostsByAuthor campo appena creato relativo al Query tipo, quindi scegliete Allega. Crea un resolver utilizzando lo snippet seguente:

    import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken, author } = ctx.arguments;
  return ddb.query({
    index: 'author-index',
    query: { author: { eq: author } },
    limit,
    nextToken,
  });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

    Come il allPost resolver, questo resolver ha due argomenti opzionali:

    • limit- Speciifica il numero massimo di elementi da restituire in una singola chiamata.

    • nextToken- Recupera il successivo set di risultati (il valore di nextToken può essere ottenuto da una chiamata precedente).

  5. Salva tutte le modifiche apportate al tuo resolver.

Per ulteriori informazioni sulla Query richiesta, consulta la documentazione di riferimento di Query.

Chiama l'API per interrogare tutti i post per autore

Ora che il resolver è stato configurato, AWS AppSync sa come tradurre una allPostsByAuthor mutazione in entrata in un'operazione DynamoDB sull'indice. Query author-index Puoi ora eseguire una query sulla tabella per recuperare tutti i post di un autore specifico.

Prima di questo, tuttavia, riempiamo la tabella con altri post, perché finora tutti i post hanno lo stesso autore.

Per aggiungere dati e interrogare

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente mutazione:

    mutation addPost {
  post1: addPost(id:10 author: "Nadia" title: "The cutest dog in the world" content: "So cute. So very, very cute." url: "https://aws.amazon.com/appsync/" ) { author, title }
  post2: addPost(id:11 author: "Nadia" title: "Did you know...?" content: "AppSync works offline?" url: "https://aws.amazon.com/appsync/" ) { author, title }
  post3: addPost(id:12 author: "Steve" title: "I like GraphQL" content: "It's great" url: "https://aws.amazon.com/appsync/" ) { author, title }
}

  3. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. addPost

  4. Esegui ora la query sulla tabella, per restituire tutti i post il cui autore è Nadia. Nel riquadro Interrogazioni, aggiungi la seguente interrogazione: 

    query allPostsByAuthor {
  allPostsByAuthor(author: "Nadia") {
    posts {
      id
      title
    }
    nextToken
  }
}

  5. Scegli Esegui (il pulsante di riproduzione arancione), quindi scegliallPostsByAuthor. Tutti i post creati da Nadia dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you know...?"
        }
      ],
      "nextToken": null
    }
  }
}

  6. La paginazione funziona per Query esattamente come per Scan. Ad esempio, cerchiamo tutti i post di AUTHORNAME, restituendone cinque per volta.

  7. Nel riquadro Interrogazioni, aggiungi la seguente query: 

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  8. Scegli Esegui (il pulsante di riproduzione arancione), quindi scegliallPostsByAuthor. Tutti i post creati da AUTHORNAME dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "6",
          "title": "A series of posts, Volume 6"
        },
        {
          "id": "4",
          "title": "A series of posts, Volume 4"
        },
        {
          "id": "2",
          "title": "A series of posts, Volume 2"
        },
        {
          "id": "7",
          "title": "A series of posts, Volume 7"
        },
        {
          "id": "1",
          "title": "A series of posts, Volume 1"
        }
      ],
      "nextToken": "<token>"
    }
  }
}

  9. Aggiornare l'argomento nextToken con il valore restituito dalla query precedente, come segue:

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "AUTHORNAME"
    limit: 5
    nextToken: "<token>"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  10. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. allPostsByAuthor I post rimanenti creati da AUTHORNAME dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "8",
          "title": "A series of posts, Volume 8"
        },
        {
          "id": "5",
          "title": "A series of posts, Volume 5"
        },
        {
          "id": "3",
          "title": "A series of posts, Volume 3"
        },
        {
          "id": "9",
          "title": "A series of posts, Volume 9"
        }
      ],
      "nextToken": null
    }
  }
}

Utilizzo dei set

Fino a questo punto, il Post tipo era un oggetto chiave/valore piatto. Puoi anche modellare oggetti complessi con il tuo resolver, come set, elenchi e mappe. Aggiorniamo ora il tipo Post perché includa tag. Un post può avere zero o più tag, che vengono archiviati in DynamoDB come set di stringhe. Dobbiamo anche configurare alcune mutazioni per aggiungere e rimuovere tag e una query per analizzare i post con un tag specifico.

Per configurare i tuoi dati

  1. Nella tua API, scegli la scheda Schema.

  2. Nel riquadro Schema, modificare il tipo Post per aggiungere un nuovo campo tags come segue:

    type Post {
  id: ID!
  author: String
  title: String
  content: String
  url: String
  ups: Int!
  downs: Int!
  version: Int!
  tags: [String!]
}

  3. Nel riquadro Schema, modificare il tipo Query per aggiungere una nuova query allPostsByTag come segue:

    type Query {
  allPostsByTag(tag: String!, limit: Int, nextToken: String): PaginatedPosts!
  allPostsByAuthor(author: String!, limit: Int, nextToken: String): PaginatedPosts!
  allPost(limit: Int, nextToken: String): PaginatedPosts!
  getPost(id: ID): Post
}

  4. Nel riquadro Schema, modifica il Mutation tipo per aggiungere nuove addTag e removeTag mutazioni come segue:

    type Mutation {
  addTag(id: ID!, tag: String!): Post
  removeTag(id: ID!, tag: String!): Post
  deletePost(id: ID!, expectedVersion: Int): Post
  upvotePost(id: ID!): Post
  downvotePost(id: ID!): Post
  updatePost(
    id: ID!,
    author: String,
    title: String,
    content: String,
    url: String,
    expectedVersion: Int!
  ): Post
  addPost(
    author: String!,
    title: String!,
    content: String!,
    url: String!
  ): Post!
}

  5. Scegli Save Scheme (Salva schema).

  6. Nel riquadro Resolver a destra, individuate il allPostsByTag campo appena creato relativo al Query tipo, quindi scegliete Allega. Crea il tuo resolver usando lo snippet qui sotto:

    import * as ddb from '@aws-appsync/utils/dynamodb';

export function request(ctx) {
  const { limit = 20, nextToken, tag } = ctx.arguments;
  return ddb.scan({ limit, nextToken, filter: { tags: { contains: tag } } });
}

export function response(ctx) {
  const { items: posts = [], nextToken } = ctx.result;
  return { posts, nextToken };
}

  7. Salva tutte le modifiche che hai apportato al tuo resolver.

  8. Ora, fai lo stesso per il Mutation campo addTag usando lo snippet qui sotto:

    Nota

    Sebbene le utilità DynamoDB attualmente non supportino le operazioni sui set, puoi comunque interagire con i set creando tu stesso la richiesta.

    import { util } from '@aws-appsync/utils'

export function request(ctx) {
	const { id, tag } = ctx.arguments
	const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 })
	expressionValues[':tags'] = util.dynamodb.toStringSet([tag])

	return {
		operation: 'UpdateItem',
		key: util.dynamodb.toMapValues({ id }),
		update: {
			expression: `ADD tags :tags, version :plusOne`,
			expressionValues,
		},
	}
}

export const response = (ctx) => ctx.result

  9. Salva tutte le modifiche apportate al tuo resolver.

  10. Ripeti l'operazione ancora una volta per il Mutation campo removeTag utilizzando lo snippet seguente:

    import { util } from '@aws-appsync/utils';
	
export function request(ctx) {
	  const { id, tag } = ctx.arguments;
	  const expressionValues = util.dynamodb.toMapValues({ ':plusOne': 1 });
	  expressionValues[':tags'] = util.dynamodb.toStringSet([tag]);
	
	  return {
	    operation: 'UpdateItem',
	    key: util.dynamodb.toMapValues({ id }),
	    update: {
	      expression: `DELETE tags :tags ADD version :plusOne`,
	      expressionValues,
	    },
	  };
	}
	
	export const response = (ctx) => ctx.resultexport

  11. Salva tutte le modifiche apportate al tuo resolver.

Chiamata dell'API per usare tag

Ora che hai configurato i resolver, AWS AppSync sa come tradurre le richieste in entrata addTag e le richieste allPostsByTag in DynamoDB e nelle operazioni. removeTag UpdateItem Scan Per provare, selezioniamo uno dei post creati prima. Ad esempio, è possibile utilizzare un post redatto dall'utente Nadia.

Per usare i tag

  1. Nella tua API, scegli la scheda Query.

  2. Nel riquadro Query, aggiungi la seguente query:

    query allPostsByAuthor {
  allPostsByAuthor(
    author: "Nadia"
  ) {
    posts {
      id
      title
    }
    nextToken
  }
}

  3. Scegli Esegui (il pulsante di riproduzione arancione), quindi scegliallPostsByAuthor.

  4. Tutti i post di Nadia dovrebbero apparire nel riquadro Risultati a destra del riquadro Query. La schermata visualizzata dovrebbe risultare simile a quella nell'immagine seguente:

    {
  "data": {
    "allPostsByAuthor": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world"
        },
        {
          "id": "11",
          "title": "Did you known...?"
        }
      ],
      "nextToken": null
    }
  }
}

  5. Usiamo quello con il titolo Il cane più carino del mondo. Registralo id perché lo userai più tardi. Ora proviamo ad aggiungere un dog tag.

  6. Nel riquadro Query, aggiungi la seguente mutazione. Dovremo anche aggiornare l'argomento id sul valore che abbiamo annotato in precedenza.

    mutation addTag {
  addTag(id:10 tag: "dog") {
    id
    title
    tags
  }
}

  7. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegli. addTag Il post viene aggiornato con il nuovo tag:

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

  8. Puoi aggiungere altri tag. Aggiorna la mutazione per cambiare l'tagargomento inpuppy:

    mutation addTag {
  addTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

  9. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegliaddTag. Il post viene aggiornato con il nuovo tag:

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog",
        "puppy"
      ]
    }
  }
}

  10. Puoi anche eliminare i tag. Nel riquadro Query, aggiungi la seguente mutazione. Dovrai anche aggiornare l'idargomento al valore annotato in precedenza:

    mutation removeTag {
  removeTag(id:10 tag: "puppy") {
    id
    title
    tags
  }
}

  11. Scegli Esegui (il pulsante arancione di riproduzione), quindi scegliremoveTag. Il post viene aggiornato e il tag puppy viene eliminato.

    {
  "data": {
    "addTag": {
      "id": "10",
      "title": "The cutest dog in the world",
      "tags": [
        "dog"
      ]
    }
  }
}

  12. Puoi anche cercare tutti i post che hanno un tag. Nel riquadro Interrogazioni, aggiungi la seguente query: 

    query allPostsByTag {
  allPostsByTag(tag: "dog") {
    posts {
      id
      title
      tags
    }
    nextToken
  }
}

  13. Scegli Esegui (il pulsante di riproduzione arancione), quindi scegliallPostsByTag. Vengono restituiti tutti i post con il tag dog come segue:

    {
  "data": {
    "allPostsByTag": {
      "posts": [
        {
          "id": "10",
          "title": "The cutest dog in the world",
          "tags": [
            "dog",
            "puppy"
          ]
        }
      ],
      "nextToken": null
    }
  }
}

Conclusioni

In questo tutorial, hai creato un'API che ti consente di manipolare Post oggetti in DynamoDB AWS AppSync utilizzando GraphQL.

Per eseguire la pulizia, puoi eliminare l'API AWS AppSync GraphQL dalla console.

Per eliminare il ruolo associato alla tabella DynamoDB, seleziona l'origine dati nella tabella Fonti dati e fai clic su modifica. Annota il valore del ruolo in Crea o usa un ruolo esistente. Vai alla console IAM per eliminare il ruolo.

Per eliminare la tabella DynamoDB, fai clic sul nome della tabella nell'elenco delle fonti di dati. Si accede alla console DynamoDB dove è possibile eliminare la tabella.